# 1. install the workspace (once)
pnpm install

# 2. configure the three required env vars
cp packages/sdk/examples/env.example packages/sdk/.env
#   DEVNET_RPC_URL      devnet RPC HTTP endpoint
#   DEVNET_RPC_WS_URL   devnet RPC websocket endpoint
#   DEMO_PAYER_SECRET   a FUNDED devnet keypair (JSON u8 array)
#   DEMO_USDC_MINT      the devnet USDC mint

# 3. run the example scripts
cd packages/sdk
bun run example:register   # register an agent  -> prints the AgentIdentity PDA
bun run example:query      # read its reputation -> prints the decoded fields
bun run example:escrow     # create + dispute an escrow on devnet

import {
  createSolanaRpc,
  createSolanaRpcSubscriptions,
  sendAndConfirmTransactionFactory,
  type Instruction,
} from "@solana/kit";
import { deriveAgentIdentity, registerAgent } from "@agentmesh/sdk";

const rpc = createSolanaRpc(env.rpcUrl);
const [identity] = await deriveAgentIdentity(payer.address);

const ix: Instruction = registerAgent({
  agent: identity,            // the AgentIdentity PDA
  owner: payer,               // a Kit TransactionSigner (the paying authority)
  agentPubkey: payer.address, // the agent's signing key
  category: 0,                // capability category
  capabilitiesUri: "https://my-agent.example/capabilities.json",
});

// build -> sign -> sendAndConfirm (see examples/_shared.ts: buildAndSign)
const sendAndConfirm = sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions });
await sendAndConfirm(signed, { commitment: "confirmed" });

import {
  stakeAndMint,
  deriveProtocolConfig,
  deriveAgentIdentity,
  deriveStakeAccount,
  deriveRepuBondMint,
  deriveRepuAuthority,
  deriveSlashAuthority,
} from "@agentmesh/sdk";

const [config]        = await deriveProtocolConfig();
const [agent]         = await deriveAgentIdentity(owner.address);
const [stakeAccount]  = await deriveStakeAccount(agent);
const [repubondMint]  = await deriveRepuBondMint();
const [repuAuthority] = await deriveRepuAuthority();
const [slashAuthority]= await deriveSlashAuthority();

const ixs = await stakeAndMint({
  config, agent, stakeAccount, owner,
  usdcMint, agentUsdc, stakeVault: stakeAccount,
  repubondMint, agentRepubondAta, repuAuthority, slashAuthority,
  usdcTokenProgram,
  amount: 1_000_000n,        // 1 USDC (6 decimals)
});

import { createSolanaRpc } from "@solana/kit";
import { queryReputation } from "@agentmesh/sdk";

const rpc = createSolanaRpc(env.rpcUrl);

// derives the AgentIdentity PDA from the agent pubkey itself
const account = await queryReputation(rpc, agentPubkey);

console.log(account); // decoded reputation fields (score, stake, slash_count, ...)

import { createEscrow, releaseEscrow, dispute } from "@agentmesh/sdk";

// 1. Buyer escrows funds against a seller agent (reputation-gated)
const create = createEscrow({ /* buyer, seller agent, amount, ... */ });

// 2a. Happy path — release to the seller
const release = releaseEscrow({ /* escrow, seller, ... */ });

// 2b. Dispute path — open a dispute; the Squads V4 council returns
//     ReleaseToSeller | RefundToBuyer | Split, and an adverse verdict
//     CPIs into the reputation program to slash the seller.
const open = dispute({ /* escrow, buyer, reason, ... */ });

import { createX402Provider, PAYMENT_HEADER } from "@agentmesh/agent-common/x402-provider";

// A request WITHOUT a valid 'payment-signature' header gets a 402 challenge.
// A request WITH one is verified against the facilitator (SettlementVerifier)
// BEFORE the route handler runs — fail-closed.
const provider = createX402Provider({
  routes: { /* ProviderRouteConfig: price + handler per path */ },
  verifier: settlementVerifier, // checks on-chain settlement
});
// PAYMENT_HEADER === "payment-signature"

import { createPayshConsumer, CONSUMER_PAYMENT_HEADER } from "@agentmesh/agent-common/paysh-consumer";

// fetch() -> 402 challenge -> settle a proof at the facilitator -> retry
// the same request WITH the proof in the CONSUMER_PAYMENT_HEADER -> 200.
const consumer = createPayshConsumer({
  settler: paymentLegSettler,   // mints + settles the proof (pay.sh)
  fetch: globalThis.fetch,
});

import { selfRegister } from "@agentmesh/agent-common/self-register";

// registerAgent + stakeAndMint in one step, from the agent's own key.
await selfRegister(
  secretKey,
  { usdcMint, stakeAmount: 1_000_000n, capabilitiesUri: "https://agent.example/cap.json" },
  submitter, // a SelfRegisterSubmitter (send-and-confirm seam)
);

import {
  deriveAgentIdentity,     // (owner)            -> AgentIdentity PDA
  deriveStakeAccount,      // (agent)            -> stake account PDA
  deriveProtocolConfig,    // ()                 -> ProtocolConfig PDA
  deriveRepuBondMint,      // ()                 -> RepuBond mint PDA
  deriveRepuAuthority,     // ()                 -> mint authority PDA
  deriveSlashAuthority,    // ()                 -> slash authority PDA (escrow-pinned)
  deriveInsuranceVault,    // ()                 -> insurance fund PDA
  deriveEscrow,            // (...)              -> escrow PDA
  deriveEscrowConfig,      // ()                 -> escrow config PDA
} from "@agentmesh/sdk";

const [identity] = await deriveAgentIdentity(owner.address);
const [mint]     = await deriveRepuBondMint();   // returns [Address, bump]