Identity

import { AgentIdentity } from "@a3stack/identity";
import { base } from "viem/chains";
import { privateKeyToAccount } from "viem/accounts";

const account = privateKeyToAccount(process.env.PRIVATE_KEY);
const identity = new AgentIdentity({
  account,
  chain: base,
  rpc: "https://mainnet.base.org", // optional
  // registry: "0x8004...",         // optional, uses default
});

const { agentId, globalId, txHash } = await identity.register({
  name: "MyAgent",
  description: "An AI agent that does X",
  image: "https://example.com/agent-logo.png",  // optional
  services: [
    {
      name: "MCP",
      endpoint: "https://mcp.myagent.ai/mcp",
      version: "2025-06-18",
    },
    {
      name: "web",
      endpoint: "https://myagent.ai",
    },
  ],
  x402Support: true,    // accepts x402 payments
  active: true,
  supportedTrust: ["reputation"], // optional
});

// globalId: "eip155:8453:0x8004A169FB4a3325136EB29fA0ceB6D2e539a432#42"
console.log(`Registered! ID: ${globalId}`);
console.log(`Tx: https://basescan.org/tx/${txHash}`);

const { registered, agentId } = await identity.isRegistered();

if (registered) {
  console.log(`Already registered as #${agentId}`);
} else {
  console.log("Not yet registered on this chain");
}

// Update your registration after deploy (e.g., new MCP endpoint)
await identity.setAgentURI(agentId, "https://new-uri.com/agent.json");

// Link a separate payment wallet to your agent
// (proves control of newWallet via EIP-712 signature)
const deadline = Math.floor(Date.now() / 1000) + 3600; // 1 hour
await identity.setPaymentWallet(agentId, "0xNewWallet...", deadline, signature);

// Get the current payment wallet
const wallet = await identity.getPaymentWallet(agentId);

import { verifyAgent } from "@a3stack/identity";

// Verify by global agent ID (recommended)
const result = await verifyAgent("eip155:8453:0x8004...#2376");

console.log(result.valid);                         // true / false
console.log(result.owner);                         // "0x1be93C..."
console.log(result.paymentWallet);                 // null (defaults to owner)
console.log(result.registration);                  // full AgentRegistration
console.log(result.registration?.services);        // [{ name: "MCP", ... }]
console.log(result.registration?.x402Support);     // true

// On failure:
console.log(result.error);  // e.g., "agentId mismatch in back-reference"

// Verify by chain + numeric agentId
const result = await verifyAgent({ chain: base, agentId: 2376 });

// Find all agents by owner wallet
import { findAgentsByOwner } from "@a3stack/identity";
const agents = await findAgentsByOwner("0x1be93C...", { chain: base });

import { AgentDiscovery } from "@a3stack/identity";

const discovery = new AgentDiscovery({
  chainId: 8453,          // Base
  rpcUrl: "https://base-mainnet.g.alchemy.com/v2/YOUR_KEY",
});

// Search agents across the ecosystem (subgraph-indexed)
const agents = await discovery.search({ name: "weather" });

// Search with reputation filter
const trusted = await discovery.search({
  feedback: { minValue: 80 },
  active: true,
});

// Get reputation summary for an agent
const rep = await discovery.getReputation("8453:102");
console.log(`Score: ${rep.averageValue}/100 (${rep.count} reviews)`);

// Get detailed feedback entries
const reviews = await discovery.getFeedback("1:22775");
for (const r of reviews) {
  console.log(`${r.value}/100 by ${r.reviewer} — [${r.tags.join(", ")}]`);
}

import { A3Stack } from "@a3stack/core";

// Integrated into the main A3Stack class
const stack = new A3Stack({ account, chain: base, rpc: "..." });

const agents = await stack.discover({ name: "weather" });
const rep = await stack.reputation("8453:102");
const reviews = await stack.feedback("1:22775");

import { parseAgentId } from "@a3stack/identity";

const ref = parseAgentId("eip155:8453:0x8004A169FB4a3325136EB29fA0ceB6D2e539a432#2376");
// {
//   namespace: "eip155",
//   chainId: 8453,
//   registry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
//   agentId: 2376
// }

import { getMcpEndpoint, getA2aEndpoint } from "@a3stack/identity";

const mcpUrl = await getMcpEndpoint("eip155:8453:0x8004...#2376");
// "https://mcp.arcabot.ai/mcp"

const a2aUrl = await getA2aEndpoint("eip155:8453:0x8004...#2376");
// null (if not configured)

import { findAllRegistrations } from "@a3stack/core";

// Find all registrations across all supported chains for a wallet
const regs = await findAllRegistrations("0x1be93C...");
// [
//   { chainName: "Base", chainId: 8453, agentId: 2376, globalId: "eip155:8453:..." },
//   { chainName: "Ethereum", chainId: 1, agentId: 88, globalId: "eip155:1:..." },
//   ...
// ]

import { discoverAgents } from "@a3stack/identity";

const agents = await discoverAgents({
  chain: base,
  filter: {
    hasService: "MCP",      // has an MCP endpoint
    x402Support: true,       // accepts payments
    active: true,
  }
});
// Returns AgentRegistration[] with resolved registration files

interface AgentRegistration {
  type: string;
  name: string;
  description: string;
  image?: string;
  services: AgentService[];
  x402Support: boolean;
  active: boolean;
  registrations: AgentRef[];       // cross-chain registrations
  supportedTrust?: string[];
}

interface AgentService {
  name: string;       // "MCP" | "A2A" | "web" | "ENS" | ...
  endpoint: string;
  version?: string;
  skills?: string[];
  domains?: string[];
}

interface AgentRef {
  namespace: string;       // "eip155"
  chainId: number;         // 8453
  registry: `0x${string}`;
  agentId: number;
}

interface VerificationResult {
  valid: boolean;
  agentId: number;
  owner: string;
  paymentWallet: string | null;
  registration: AgentRegistration | null;
  error?: string;
}

$npx a3stack verify eip155:8453:0x8004A169FB4a3325136EB29fA0ceB6D2e539a432#2376

$npx a3stack lookup 0x1be93C...