How to Register and Monetize AI Agents with x402 Payment Protocol

npm install @hashgraphonline/standards-sdk

npm install x402-axios x402

  RegistryBrokerClient,
  ProfileType,
  AIAgentType,
  AIAgentCapability,
  type AgentRegistrationRequest 
} from '@hashgraphonline/standards-sdk';

// Initialize the client
const client = new RegistryBrokerClient({ 
  baseUrl: 'https://hol.org/registry/api/v1' 
});

async function checkRegistrationCosts(
  payload: AgentRegistrationRequest
): Promise<{ canRegister: boolean; shortfall: number; creditsPerHbar: number }> {
  const quote = await client.getRegistrationQuote(payload);

  console.log('Registration Quote:');
  console.log(  Required credits: ${quote.requiredCredits});
  console.log(  Current balance: ${quote.currentCredits ?? &#39;unknown&#39;});
  console.log(  Shortfall: ${quote.shortfallCredits ?? 0});
  console.log(  Credits per HBAR: ${quote.creditsPerHbar});
  const shortfall = quote.shortfallCredits ?? 0;

async function purchaseCreditsHbar(
  shortfall: number, 
  creditsPerHbar: number
): Promise<void> {
  // Calculate HBAR needed (with small buffer)
  const creditsTourchase = Math.max(shortfall + 10, 100); // Minimum 100 credits
  const hbarAmount = Math.ceil((creditsTourchase / creditsPerHbar) * 1e8) / 1e8;

  console.log(Purchasing ${creditsTourchase} credits for ${hbarAmount} HBAR...);
  const receipt = await client.purchaseCreditsWithHbar({
    accountId: process.env.HEDERA_ACCOUNT_ID!,
    privateKey: process.env.HEDERA_PRIVATE_KEY!,
    hbarAmount: hbarAmount,
    memo: 'Agent registration credits',
    metadata: {
      purpose: 'agent-registration',
      requestedCredits: creditsTourchase,
    },
  });

async function purchaseCreditsX402(shortfall: number): Promise<void> {
  // Get minimum purchase requirements
  const minimums = await client.getX402Minimums();
  const creditsTourchase = Math.max(
    shortfall,
    minimums.baseCredits ?? 100
  );
  console.log(Purchasing ${creditsTourchase} credits via x402...);
  console.log(  Minimum purchase: ${minimums.baseCredits} credits);
  console.log(  USD amount: $${minimums.usdAmount ?? &#39;varies&#39;});
  // Create the x402 signer from your EVM private key
  const privateKey = process.env.EVM_PRIVATE_KEY as 0x${string};
  const walletClient = await createSigner('base-sepolia', privateKey);
  const receipt = await client.purchaseCreditsWithX402({
    accountId: process.env.HEDERA_ACCOUNT_ID!,
    credits: creditsTourchase,
    description: 'Agent registration via x402',
    metadata: {
      source: 'my-app',
      environment: 'production',
    },
    walletClient,
  });

async function registerAgentWithCredits(
  payload: AgentRegistrationRequest
): Promise<string> {
  // Check if we need credits
  const { canRegister, shortfall, creditsPerHbar } = 
    await checkRegistrationCosts(payload);

  if (!canRegister) {
    console.log(Need ${shortfall} more credits. Purchasing...);
    await purchaseCreditsHbar(shortfall, creditsPerHbar);
  }
  // Perform the registration
  const response = await client.registerAgent(payload);
  console.log('Agent registered successfully!');
  console.log(  UAID: ${response.uaid});
  console.log(  Status: ${response.status});
  // If registration is async, wait for completion
  if (response.attemptId) {
    console.log('Waiting for registration to complete...');
    const progress = await client.waitForRegistrationCompletion(
      response.attemptId,
      {
        intervalMs: 2000,
        timeoutMs: 60000,
        onProgress: (status) => {
          console.log(  Progress: ${status.status});
        },
      }
    );
    console.log(Final status: ${progress.status});
  }

async function registerWithAutoRetry(
  payload: AgentRegistrationRequest
): Promise<string> {
  try {
    const response = await client.registerAgent(payload);
    return response.uaid!;
  } catch (error) {
    if (error instanceof RegistryBrokerError && error.status === 402) {
      // Extract shortfall information from error body
      const body = error.body as Record<string, unknown>;
      const shortfall = Number(body.shortfallCredits ?? 0);
      const creditsPerHbar = Number(body.creditsPerHbar ?? 0);
  if (shortfall &gt; 0 &amp;&amp; creditsPerHbar &gt; 0) {
    console.log(`Registration requires ${shortfall} more credits`);
    await purchaseCreditsHbar(shortfall, creditsPerHbar);

    // Retry the registration
    const retryResponse = await client.registerAgent(payload);
    return retryResponse.uaid!;
  }
}
throw error;

const productionClient = new RegistryBrokerClient({
  baseUrl: 'https://hol.org/registry/api/v1',
  registrationAutoTopUp: {
    accountId: process.env.HEDERA_ACCOUNT_ID!,
    privateKey: process.env.HEDERA_PRIVATE_KEY!,
    memo: 'auto-topup',
  },
});