AgentPay N3

const AGENT_REGISTRY_HASH = '0x9bae46744fbd512506e77fc7dcca6cd0f7cee495';
const TESTNET_MAGIC = 894710606;

function ensureHash160(value) {
  return value.startsWith('0x') ? value : `0x${value}`;
}

function delay(ms) {
  return new Promise((resolve) => window.setTimeout(resolve, ms));
}

function normalizeTxid(value) {
  if (typeof value === 'string' && value) {
    return value;
  }

  if (value && typeof value.txid === 'string' && value.txid) {
    return value.txid;
  }

  if (value && typeof value.txId === 'string' && value.txId) {
    return value.txId;
  }

  throw new Error('Wallet returned an unexpected transaction hash response.');
}

function getNeoLineProvider() {
  return new Promise((resolve, reject) => {
    let settled = false;
    const readyHandler = (event) => {
      const candidate = event.detail?.provider;
      if (candidate?.name !== 'NeoLine') return;
      settled = true;
      window.removeEventListener('Neo.DapiProvider.ready', readyHandler);
      resolve(candidate);
    };

    window.addEventListener('Neo.DapiProvider.ready', readyHandler);
    window.dispatchEvent(new Event('Neo.DapiProvider.request'));

    window.setTimeout(() => {
      if (settled) return;
      window.removeEventListener('Neo.DapiProvider.ready', readyHandler);
      reject(new Error('NeoLine not found. Install or unlock the wallet first.'));
    }, 2500);
  });
}

async function getSigningAccount(provider) {
  const accounts = await provider.getAccounts();
  if (accounts.length === 1) {
    return accounts[0];
  }

  const selectedAddress = await provider.pickAddress('Choose the wallet that should receive agent payouts.');
  const selected = (await provider.getAccounts()).find((account) => account.address === selectedAddress);
  if (!selected) {
    throw new Error('Selected account is not available.');
  }

  return selected;
}

async function getNextAgentId(provider) {
  const result = await provider.call({
    hash: AGENT_REGISTRY_HASH,
    operation: 'getNextAgentId',
  });

  return result.stack[0].value;
}

async function waitForRegisteredAgentId(provider, txid, fallbackAgentId) {
  for (let attempt = 0; attempt < 10; attempt += 1) {
    try {
      const log = await provider.getApplicationLog(txid);
      const notification = log.executions
        .flatMap((execution) => execution.notifications || [])
        .find((entry) => entry.contract === AGENT_REGISTRY_HASH && entry.eventname === 'AgentRegistered');

      if (notification?.state?.type === 'Array') {
        return notification.state.value[0].value;
      }
    } catch {
      // The tx can take a few blocks to appear in the application log.
    }

    await delay(1500);
  }

  return fallbackAgentId;
}

async function registerWithNeoLine(metadataUri) {
  if (!metadataUri || metadataUri.length > 512) {
    throw new Error('metadataUri must be between 1 and 512 characters.');
  }

  const provider = await getNeoLineProvider();
  if (provider.network !== TESTNET_MAGIC) {
    throw new Error('Switch the wallet to Neo N3 TestNet first.');
  }

  const expectedAgentId = await getNextAgentId(provider);
  const account = await getSigningAccount(provider);
  const accountHash = ensureHash160(account.hash);
  const txid = normalizeTxid(await provider.invoke(
    [{
      hash: AGENT_REGISTRY_HASH,
      operation: 'registerAgent',
      args: [
        { type: 'Hash160', value: accountHash },
        { type: 'String', value: metadataUri },
      ],
      abortOnFail: true,
    }],
    [{
      account: accountHash,
      scopes: 'CalledByEntry',
    }],
  ));

  return { provider, expectedAgentId, address: account.address, txid };
}

async function confirmRegistration(provider, txid, expectedAgentId) {
  const agentId = await waitForRegisteredAgentId(provider, txid, expectedAgentId);
  return { agentId, txid };
}

// Example:
// const submission = await registerWithNeoLine('https://example.com/agent.json');
// const confirmation = await confirmRegistration(submission.provider, submission.txid, submission.expectedAgentId);