How to Build an Agent That Pays for Its Own API Calls

mkdir ergo-agent-api && cd ergo-agent-api
npm init -y
npm install @fleet-sdk/core express node-fetch

// agent-wallet.js
const TESTNET_API = "https://api-testnet.ergoplatform.com";

export const wallet = {
  address: "YOUR_TESTNET_ADDRESS",  // ← paste your testnet address
  // In production: store private key in KMS, HSM, or env var
  // privateKey: process.env.AGENT_PRIVATE_KEY

  async getInputs() {
    const res = await fetch(
      `${TESTNET_API}/api/v1/boxes/unspent/byAddress/${this.address}`
    );
    const { items } = await res.json();
    return items ?? [];
  },

  async getHeight() {
    const res = await fetch(`${TESTNET_API}/api/v1/info`);
    const { fullHeight } = await res.json();
    return fullHeight;
  }
};

// api-server.js
import express from "express";

const app = express();
app.use(express.json());

const TESTNET_API = "https://api-testnet.ergoplatform.com";
const API_ADDRESS  = "YOUR_API_SERVICE_ADDRESS"; // ← API's receiving address
const PRICE_NANOERG = 1000000; // 0.001 ERG per call

// Verify payment: check blockchain for UTxO at API_ADDRESS
// with callId encoded in R4
async function verifyPayment(callId) {
  const res = await fetch(
    `${TESTNET_API}/api/v1/boxes/unspent/byAddress/${API_ADDRESS}`
  );
  const { items } = await res.json();

  return items?.some(box => {
    const r4 = box.additionalRegisters?.R4;
    if (!r4) return false;
    // R4 is hex-encoded: "0e" prefix + hex(callId)
    const decodedR4 = Buffer.from(r4.slice(4), "hex").toString();
    return decodedR4 === callId && box.value >= PRICE_NANOERG;
  }) ?? false;
}

// Paid endpoint
app.post("/api/analyze", async (req, res) => {
  const { callId, txId, data } = req.body;

  if (!callId || !txId) {
    return res.status(400).json({ error: "callId and txId required" });
  }

  // Check payment (with simple polling for testnet)
  let paid = false;
  for (let attempt = 0; attempt < 5; attempt++) {
    paid = await verifyPayment(callId);
    if (paid) break;
    await new Promise(r => setTimeout(r, 3000)); // wait 3s between checks
  }

  if (!paid) {
    return res.status(402).json({
      error: "Payment required",
      payTo: API_ADDRESS,
      price: PRICE_NANOERG,
      callId,
    });
  }

  // Payment confirmed — return result
  res.json({
    callId,
    result: `Analysis complete for: ${data}`,
    timestamp: Date.now(),
  });
});

app.listen(3001, () => console.log("API service running on :3001"));

// agent-pay.js
import { TransactionBuilder, OutputBuilder, SColl, SByte } from "@fleet-sdk/core";
import { wallet } from "./agent-wallet.js";

const TESTNET_API  = "https://api-testnet.ergoplatform.com";
const API_ADDRESS  = "YOUR_API_SERVICE_ADDRESS";
const PRICE_NANOERG = 1000000; // 0.001 ERG

export async function payForAPICall(callId) {
  const height = await wallet.getHeight();
  const inputs = await wallet.getInputs();

  if (!inputs.length) throw new Error("No UTxOs — fund your agent wallet");

  // Encode callId in R4 so the API can match payment to call
  const paymentOutput = new OutputBuilder(PRICE_NANOERG.toString(), API_ADDRESS)
    .setAdditionalRegisters({
      R4: SColl(SByte, Buffer.from(callId, "utf8")),
    });

  const unsignedTx = new TransactionBuilder(height)
    .from(inputs)
    .to(paymentOutput)
    .sendChangeTo(wallet.address)
    .payMinFee()
    .build()
    .toEIP12Object();

  // NOTE: In this tutorial you must sign externally (Nautilus or server key)
  // For production server-side signing, see: sigma-rust or ergo-lib-wasm
  console.log("Unsigned TX (sign and submit):");
  console.log(JSON.stringify(unsignedTx, null, 2));

  // After signing and submitting, return the txId
  // const txId = await submitSignedTx(signedTx);
  // return txId;
}

// agent.js — the autonomous agent
import { payForAPICall } from "./agent-pay.js";

async function runAgent(data) {
  const callId = `call-${Date.now()}-${Math.random().toString(36).slice(2)}`;

  console.log(`[Agent] Task: analyze "${data}"`);
  console.log(`[Agent] Call ID: ${callId}`);

  // 1. Pay for the API call
  console.log("[Agent] Sending payment...");
  const txId = await payForAPICall(callId);
  // (in this tutorial: manually sign and submit the printed TX)
  // txId = "the submitted transaction ID"

  // 2. Call the paid API (with callId + txId as proof of payment)
  console.log("[Agent] Calling API...");
  const res = await fetch("http://localhost:3001/api/analyze", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ callId, txId, data }),
  });

  if (!res.ok) {
    const err = await res.json();
    throw new Error(`API error: ${err.error}`);
  }

  const result = await res.json();
  console.log("[Agent] Result:", result);
  return result;
}

// Run
runAgent("the latest Ergo block data").catch(console.error);