The protocol assembles in 6 steps.

import { TelaroClient } from "@telaro/sdk";

const rep = new TelaroClient(connection, controller);
const sig = await rep.registerAgent({
  framework: "sendai",
  metadataUri: "https://telaro.xyz/sample/kill-demo.json",
  scorer: controller.publicKey,
  bondMint: USDC_DEVNET,
  bondAmount: 100_000_000n, // 100 USDC
});

import { ActionKind, ActionOutcome } from "@telaro/sdk";

const actions = [
  { kind: ActionKind.Swap, outcome: ActionOutcome.Success, valueAtomic: 50_000_000n, payload: { venue: "jupiter" } },
  { kind: ActionKind.Lp,   outcome: ActionOutcome.Success, valueAtomic: 200_000_000n, payload: { venue: "kamino" } },
  { kind: ActionKind.Lend, outcome: ActionOutcome.Success, valueAtomic: 500_000_000n, payload: { venue: "marginfi" } },
  { kind: ActionKind.Swap, outcome: ActionOutcome.Success, valueAtomic: 100_000_000n, payload: { venue: "jupiter" } },
  { kind: ActionKind.Vote, outcome: ActionOutcome.Success, valueAtomic: 0n,           payload: { proposal: "REALM-42" } },
];

for (const a of actions) await rep.recordAction(a);

import express from "express";
import { expressX402Gate } from "@telaro/x402";

const app = express();
app.post(
  "/premium",
  expressX402Gate(
    { minBond: 10_000_000n, minScore: 100 },
    { apiBase: "https://telaro.xyz" },
  ),
  (req, res) => {
    res.json({ ok: true, served: "premium endpoint" });
  },
);
app.listen(4242);

const header = buildX402Payment({ payer: bondedAgent, amountUsdc: 0.1 });
const ok = await fetch("http://localhost:4242/premium", {
  method: "POST",
  headers: { "Content-Type": "application/json", "X-PAYMENT": header },
  body: JSON.stringify({ prompt: "summarize this article" }),
});

const reject = await fetch("http://localhost:4242/premium", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    "X-PAYMENT": buildX402Payment({ payer: Keypair.generate(), amountUsdc: 0.1 }),
  },
  body: JSON.stringify({ prompt: "summarize this article" }),
});

import { hashAction, ResolveAction, TelaroClient } from "@telaro/sdk";

const rep = new TelaroClient(connection, controller);
const actionHash = hashAction({ venue: "jupiter" });

// 1. Claimer (could be anyone) files a claim with evidence.
await rep.submitClaim(
  {
    agent: rep.agentPda(),
    actionHash,
    claimedAmount: 100_000n,  // 0.1 USDC
    evidenceUri: "ipfs://demo-evidence-placeholder",
  },
  BOND_MINT,
);

// 2. Builder resolves. In production this is the builder's decision;
//    here the same wallet plays both roles so the demo is self-contained.
await rep.resolveClaim({
  agent: rep.agentPda(),
  actionHash,
  claimer: controller.publicKey,
  bondMint: BOND_MINT,
  action: ResolveAction.BuilderAccept,
});

import { expressX402Gate, type KeyLinkResolver } from "@telaro/x402";

// Plug the resolver in. Common implementations:
//   HTTP: GET /api/agent/by-payment-key/<wallet>
//   RPC:  getProgramAccounts with a memcmp on the payment_key field.
const keyLinkResolver: KeyLinkResolver = async (wallet) => {
  const res = await fetch(`/api/agent/by-payment-key/${wallet}`);
  if (!res.ok) return null;
  const body = await res.json();
  return body.agent_pda ?? null;
};

// New v1 strategy-based config (recommended for new integrations).
app.post(
  "/premium",
  expressX402Gate({
    strategy: "trust",
    policy: { minBond: 10_000_000n, minScore: 100 },
    keyLinkResolver,
  }),
  (req, res) => res.json({ ok: true }),
);

// Or compose with the sACP escrow strategy:
//   import { withSacpTrust } from "@telaro/x402/sacp";
//   app.post("/work", withSacpTrust({ sacp, policy, keyLinkResolver }), handler);