@sherwoodagent/cli 0.84.0 → 0.85.0

package/dist/chunk-ILHOW6IA.js

@@ -0,0 +1,2971 @@
+import {
+  COORDINATION_NETWORK
+} from "./chunk-M4GX5PL2.js";
+import {
+  AGENT_REGISTRY
+} from "./chunk-AM6MI2JF.js";
+import {
+  formatContractError,
+  getAccount,
+  getPublicClient,
+  sendTxWithRetry,
+  waitForReceipt
+} from "./chunk-QRMZRAMG.js";
+import {
+  getChain,
+  getChainConfig,
+  getRpcUrl,
+  withNetwork
+} from "./chunk-PVTZMRC6.js";
+import {
+  getAgentId,
+  getIdentityChainId,
+  getIdentityProvider,
+  getVirtualsIdentity,
+  requirePrivateKey,
+  setAgentId,
+  setVirtualsIdentity
+} from "./chunk-3TZIOAPH.js";
+
+// src/commands/identity.ts
+import { generatePrivateKey } from "viem/accounts";
+import chalk from "chalk";
+import ora from "ora";
+import { SDK } from "agent0-sdk";
+
+// src/lib/virtuals.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { createPublicClient, http, recoverMessageAddress, isAddress } from "viem";
+import { base, baseSepolia } from "viem/chains";
+var execFileAsync = promisify(execFile);
+var BINDING_VERSION = "v1";
+function buildBindingMessage(sherwoodEoa, issuingChainId, tokenId) {
+  return `sherwood-identity-link:${BINDING_VERSION}:${sherwoodEoa.toLowerCase()}:${issuingChainId}:${tokenId}`;
+}
+async function verifyBinding(params) {
+  try {
+    const recovered = await recoverMessageAddress({
+      message: buildBindingMessage(params.sherwoodEoa, params.issuingChainId, params.tokenId),
+      signature: params.signature
+    });
+    return recovered.toLowerCase() === params.virtualsWallet.toLowerCase();
+  } catch {
+    return false;
+  }
+}
+var robinhoodChain = {
+  id: 4663,
+  name: "Robinhood Chain",
+  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+  rpcUrls: { default: { http: ["https://rpc.mainnet.chain.robinhood.com"] } },
+  blockExplorers: {
+    default: {
+      name: "Robinhood Chain Explorer",
+      url: "https://explorer.mainnet.chain.robinhood.com"
+    }
+  }
+};
+var DEFAULT_ISSUING_CHAIN_ID = robinhoodChain.id;
+var ISSUING_CHAINS = {
+  [robinhoodChain.id]: {
+    chain: robinhoodChain,
+    identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432"
+  },
+  [base.id]: {
+    chain: base,
+    identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432"
+  },
+  [baseSepolia.id]: {
+    chain: baseSepolia,
+    identityRegistry: "0x8004A818BFB912233c491871b3d84c89A494BD9e"
+  }
+};
+var OWNER_OF_ABI = [
+  {
+    name: "ownerOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [{ name: "", type: "address" }]
+  }
+];
+var ISSUING_RPC_ENV = {
+  [robinhoodChain.id]: "ROBINHOOD_RPC_URL",
+  [base.id]: "BASE_RPC_URL",
+  [baseSepolia.id]: "BASE_SEPOLIA_RPC_URL"
+};
+async function ownerOfOnIssuingChain(issuingChainId, tokenId) {
+  const issuing = ISSUING_CHAINS[issuingChainId];
+  if (!issuing) {
+    throw new Error(
+      `Unsupported issuing chain ${issuingChainId}. Supported: ${Object.keys(ISSUING_CHAINS).join(", ")}`
+    );
+  }
+  const rpcOverride = process.env[ISSUING_RPC_ENV[issuingChainId]];
+  const client = createPublicClient({ chain: issuing.chain, transport: http(rpcOverride) });
+  return client.readContract({
+    address: issuing.identityRegistry,
+    abi: OWNER_OF_ABI,
+    functionName: "ownerOf",
+    args: [tokenId]
+  });
+}
+var WALLET_ONLY_CHAIN_ID = 0;
+var VID_TAG_RE = /\s*\[vid:(v\d+):(\d+):(\d+):(0x[0-9a-fA-F]{40}):(self|0x[0-9a-fA-F]{130})\]\s*$/;
+function formatVidTag(tag) {
+  return `[vid:${BINDING_VERSION}:${tag.issuingChainId}:${tag.tokenId}:${tag.wallet.toLowerCase()}:${tag.signature}]`;
+}
+function appendVidTag(message, tag) {
+  return `${message} ${formatVidTag(tag)}`;
+}
+function parseVidTag(message) {
+  if (message.indexOf("[vid:") !== message.lastIndexOf("[vid:")) return null;
+  const match = message.match(VID_TAG_RE);
+  if (!match) return null;
+  if (!isAddress(match[4])) return null;
+  return {
+    version: match[1],
+    issuingChainId: parseInt(match[2], 10),
+    tokenId: BigInt(match[3]),
+    wallet: match[4],
+    signature: match[5] === "self" ? "self" : match[5]
+  };
+}
+function stripVidTag(message) {
+  return message.replace(VID_TAG_RE, "");
+}
+async function verifyVidTag(tag, attester, ownerOf = ownerOfOnIssuingChain) {
+  let bindingOk;
+  if (tag.signature === "self") {
+    bindingOk = attester.toLowerCase() === tag.wallet.toLowerCase();
+  } else {
+    bindingOk = await verifyBinding({
+      sherwoodEoa: attester,
+      issuingChainId: tag.issuingChainId,
+      tokenId: tag.tokenId,
+      virtualsWallet: tag.wallet,
+      signature: tag.signature
+    });
+  }
+  if (!bindingOk) {
+    return { bindingOk: false, ownerOk: false, error: "binding failed \u2014 ownership check skipped" };
+  }
+  if (tag.issuingChainId === WALLET_ONLY_CHAIN_ID) {
+    return { bindingOk, ownerOk: true, walletOnly: true };
+  }
+  try {
+    const owner = await ownerOf(tag.issuingChainId, tag.tokenId);
+    return {
+      bindingOk,
+      ownerOk: owner.toLowerCase() === tag.wallet.toLowerCase(),
+      owner
+    };
+  } catch (err) {
+    return { bindingOk, ownerOk: false, error: err.message };
+  }
+}
+function makeOwnerOfCache() {
+  const cache = /* @__PURE__ */ new Map();
+  return (chainId, tokenId) => {
+    const key = `${chainId}:${tokenId}`;
+    let p = cache.get(key);
+    if (!p) {
+      p = ownerOfOnIssuingChain(chainId, tokenId);
+      p.catch(() => {
+      });
+      cache.set(key, p);
+    }
+    return p;
+  };
+}
+async function acpJson(args) {
+  try {
+    const { stdout } = await execFileAsync("acp", [...args, "--json"], {
+      timeout: 15e3
+    });
+    const start = stdout.indexOf("{");
+    if (start < 0) return null;
+    return JSON.parse(stdout.slice(start));
+  } catch {
+    return null;
+  }
+}
+async function detectAcp() {
+  try {
+    await execFileAsync("acp", ["--version"], { timeout: 1e4 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function acpSignMessage(message) {
+  try {
+    const { stdout } = await execFileAsync(
+      "acp",
+      ["wallet", "sign-message", "--message", message, "--json"],
+      { timeout: 6e4 }
+    );
+    const start = stdout.indexOf("{");
+    if (start < 0) return null;
+    const json = JSON.parse(stdout.slice(start));
+    const sig = json.signature;
+    return typeof sig === "string" && /^0x[0-9a-fA-F]{130}$/.test(sig) ? sig : null;
+  } catch {
+    return null;
+  }
+}
+async function acpWhoami() {
+  const json = await acpJson(["agent", "whoami"]);
+  if (!json) return null;
+  const agentId = json.agentId ?? json.id ?? json.agent?.id;
+  const name = json.name ?? json.agent?.name;
+  return {
+    agentId: agentId != null ? String(agentId) : void 0,
+    name: name != null ? String(name) : void 0
+  };
+}
+async function acpWalletAddress() {
+  const json = await acpJson(["wallet", "address"]);
+  if (!json) return null;
+  for (const key of ["address", "evmAddress", "evm", "wallet"]) {
+    const value = json[key];
+    if (typeof value === "string" && isAddress(value)) return value;
+  }
+  return null;
+}
+
+// src/lib/calldata.ts
+var _calldataOnly = false;
+function setCalldataOnly(value) {
+  _calldataOnly = value;
+}
+function isCalldataOnly() {
+  return _calldataOnly;
+}
+function emitCalldata(action) {
+  process.stdout.write(JSON.stringify(action, null, 2) + "\n");
+}
+
+// ../sdk/dist/generated/state-machines.js
+var GUARDIAN_VOTE_TYPES = [
+  "None",
+  "Approve",
+  "Block"
+];
+
+// ../sdk/dist/types.js
+var CHAIN_IDS = {
+  BASE: 8453,
+  HYPEREVM: 999,
+  ROBINHOOD: 4663,
+  ROBINHOOD_L2: 46630,
+  // Tenderly fork of Robinhood mainnet (USDG + Uniswap v3+v4) — mainnet-faithful
+  // e2e + guardian-sim environment. Ephemeral vnet; addresses in addresses.ts.
+  ROBINHOOD_FORK: 9994663
+};
+var SUPPORTED_CHAIN_IDS = [
+  CHAIN_IDS.BASE,
+  CHAIN_IDS.HYPEREVM,
+  CHAIN_IDS.ROBINHOOD,
+  CHAIN_IDS.ROBINHOOD_L2,
+  CHAIN_IDS.ROBINHOOD_FORK
+];
+
+// ../sdk/dist/errors.js
+var SdkError = class extends Error {
+  code;
+  cause;
+  constructor(code, message, cause) {
+    super(message);
+    this.code = code;
+    this.cause = cause;
+    this.name = "SdkError";
+  }
+};
+var usage = (message) => new SdkError("USAGE", message);
+var unsupported = (message) => new SdkError("UNSUPPORTED", message);
+var unavailable = (message, cause) => new SdkError("UNAVAILABLE", message, cause);
+
+// ../sdk/dist/abis.js
+var SYNDICATE_VAULT_ABI = [
+  // ERC-4626
+  {
+    name: "deposit",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "assets", type: "uint256" },
+      { name: "receiver", type: "address" }
+    ],
+    outputs: [{ name: "shares", type: "uint256" }]
+  },
+  {
+    name: "redeem",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "shares", type: "uint256" },
+      { name: "receiver", type: "address" },
+      { name: "owner", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "requestRedeem",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "shares", type: "uint256" },
+      { name: "owner", type: "address" }
+    ],
+    outputs: [{ name: "requestId", type: "uint256" }]
+  },
+  // Reads
+  {
+    name: "asset",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }]
+  },
+  {
+    name: "totalAssets",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "totalSupply",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "decimals",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint8" }]
+  },
+  {
+    name: "balanceOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "owner",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }]
+  },
+  {
+    name: "governor",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }]
+  },
+  {
+    name: "redemptionsLocked",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    name: "paused",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    name: "openDeposits",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    name: "agentFeeBps",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "setAgentFeeBps",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "bps", type: "uint256" }],
+    outputs: []
+  },
+  {
+    name: "AgentFeeUpdated",
+    type: "event",
+    inputs: [{ name: "bps", type: "uint256", indexed: false }]
+  },
+  {
+    name: "getAgentCount",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "isApprovedDepositor",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "depositor", type: "address" }],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  // Owner-side write surface
+  {
+    name: "approveDepositor",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "depositor", type: "address" }],
+    outputs: []
+  },
+  {
+    name: "removeDepositor",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "depositor", type: "address" }],
+    outputs: []
+  },
+  {
+    name: "registerAgent",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "agentAddress", type: "address" },
+      { name: "agentId", type: "uint256" }
+    ],
+    outputs: []
+  },
+  // Governor-only: mint + fund + run a single-use CallSandbox.
+  // ICallSandbox.Call is TWO fields (address,bytes). There is NO `value`.
+  {
+    name: "runSandbox",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "pid", type: "uint256" },
+      {
+        name: "calls",
+        type: "tuple[]",
+        components: [
+          { name: "target", type: "address" },
+          { name: "data", type: "bytes" }
+        ]
+      },
+      { name: "declaredTokens", type: "address[]" },
+      { name: "funding", type: "uint256" }
+    ],
+    outputs: [{ name: "sandbox", type: "address" }]
+  }
+];
+var SYNDICATE_GOVERNOR_ABI = [
+  // Propose (multi-arg). Order MUST match contract: vault, strategy,
+  // metadataURI, strategyDuration, executeCalls, settlementCalls, coProposers.
+  // Agent fee is no longer a propose() arg — it's the vault's `agentFeeBps`
+  // (owner-set), snapshotted onto the proposal at propose time and clamped to
+  // maxPerformanceFeeBps at settlement.
+  {
+    name: "propose",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "vault", type: "address" },
+      { name: "strategy", type: "address" },
+      { name: "metadataURI", type: "string" },
+      { name: "strategyDuration", type: "uint256" },
+      // The RISK ENVELOPE the proposal commits to: the ceiling the execute
+      // batch is metered against, and the declared loss allowance the
+      // settle-price guard sizes its tolerance from.
+      {
+        name: "envelope",
+        type: "tuple",
+        components: [
+          { name: "maxCapital", type: "uint256" },
+          { name: "maxDrawdownBps", type: "uint16" }
+        ]
+      },
+      {
+        name: "executeCalls",
+        type: "tuple[]",
+        components: [
+          { name: "target", type: "address" },
+          { name: "data", type: "bytes" },
+          { name: "value", type: "uint256" }
+        ]
+      },
+      // One cap per call, in ASSET UNITS — the maximum gross outflow measured
+      // around that call. Summed per batch, required <= maxCapital.
+      { name: "executeCallCaps", type: "uint256[]" },
+      {
+        name: "settlementCalls",
+        type: "tuple[]",
+        components: [
+          { name: "target", type: "address" },
+          { name: "data", type: "bytes" },
+          { name: "value", type: "uint256" }
+        ]
+      },
+      { name: "settlementCallCaps", type: "uint256[]" },
+      {
+        name: "coProposers",
+        type: "tuple[]",
+        components: [
+          { name: "agent", type: "address" },
+          { name: "splitBps", type: "uint256" }
+        ]
+      }
+    ],
+    outputs: [{ name: "proposalId", type: "uint256" }]
+  },
+  // proposeWithSandbox — same 10 args as propose, prefixed with SandboxPayload.
+  // ICallSandbox.Call is TWO fields (address,bytes). There is NO `value`:
+  // native value would open a transfer channel with no metering story
+  // (ICallSandbox.sol:44-51). Aliasing BatchExecutorLib.Call would reintroduce it.
+  {
+    name: "proposeWithSandbox",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      {
+        name: "sandbox",
+        type: "tuple",
+        components: [
+          { name: "funding", type: "uint256" },
+          {
+            name: "calls",
+            type: "tuple[]",
+            components: [
+              { name: "target", type: "address" },
+              { name: "data", type: "bytes" }
+            ]
+          },
+          { name: "declaredTokens", type: "address[]" }
+        ]
+      },
+      { name: "vault", type: "address" },
+      { name: "strategy", type: "address" },
+      { name: "metadataURI", type: "string" },
+      { name: "strategyDuration", type: "uint256" },
+      {
+        name: "envelope",
+        type: "tuple",
+        components: [
+          { name: "maxCapital", type: "uint256" },
+          { name: "maxDrawdownBps", type: "uint16" }
+        ]
+      },
+      {
+        name: "executeCalls",
+        type: "tuple[]",
+        components: [
+          { name: "target", type: "address" },
+          { name: "data", type: "bytes" },
+          { name: "value", type: "uint256" }
+        ]
+      },
+      { name: "executeCallCaps", type: "uint256[]" },
+      {
+        name: "settlementCalls",
+        type: "tuple[]",
+        components: [
+          { name: "target", type: "address" },
+          { name: "data", type: "bytes" },
+          { name: "value", type: "uint256" }
+        ]
+      },
+      { name: "settlementCallCaps", type: "uint256[]" },
+      {
+        name: "coProposers",
+        type: "tuple[]",
+        components: [
+          { name: "agent", type: "address" },
+          { name: "splitBps", type: "uint256" }
+        ]
+      }
+    ],
+    outputs: [{ name: "proposalId", type: "uint256" }]
+  },
+  // Lifecycle writes
+  {
+    name: "vote",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "proposalId", type: "uint256" },
+      { name: "support", type: "uint8" }
+    ],
+    outputs: []
+  },
+  {
+    name: "executeProposal",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "proposalId", type: "uint256" }],
+    outputs: []
+  },
+  {
+    name: "settleProposal",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "proposalId", type: "uint256" }],
+    outputs: []
+  },
+  {
+    name: "cancelProposal",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "proposalId", type: "uint256" }],
+    outputs: []
+  },
+  {
+    name: "vetoProposal",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "proposalId", type: "uint256" }],
+    outputs: []
+  },
+  // Emergency settlement (GovernorEmergency, V1.5). `unstick` is the
+  // owner-instant pre-committed-calls path; `emergencySettleWithCalls` commits
+  // a new calldata hash and opens a guardian-reviewed window. The removed
+  // `emergencySettle` is intentionally absent — it is not on the deployed impl.
+  {
+    name: "unstick",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "proposalId", type: "uint256" }],
+    outputs: []
+  },
+  {
+    name: "emergencySettleWithCalls",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "proposalId", type: "uint256" },
+      {
+        name: "calls",
+        type: "tuple[]",
+        components: [
+          { name: "target", type: "address" },
+          { name: "data", type: "bytes" },
+          { name: "value", type: "uint256" }
+        ]
+      }
+    ],
+    outputs: []
+  },
+  // Parameter setters (GovernorParameters, V1.5 — owner-instant, no timelock).
+  { name: "setVotingPeriod", type: "function", stateMutability: "nonpayable", inputs: [{ name: "newValue", type: "uint256" }], outputs: [] },
+  { name: "setExecutionWindow", type: "function", stateMutability: "nonpayable", inputs: [{ name: "newValue", type: "uint256" }], outputs: [] },
+  { name: "setVetoThresholdBps", type: "function", stateMutability: "nonpayable", inputs: [{ name: "newValue", type: "uint256" }], outputs: [] },
+  { name: "setMaxPerformanceFeeBps", type: "function", stateMutability: "nonpayable", inputs: [{ name: "newValue", type: "uint256" }], outputs: [] },
+  { name: "setMaxStrategyDuration", type: "function", stateMutability: "nonpayable", inputs: [{ name: "newValue", type: "uint256" }], outputs: [] },
+  { name: "setCooldownPeriod", type: "function", stateMutability: "nonpayable", inputs: [{ name: "newValue", type: "uint256" }], outputs: [] },
+  // Reads
+  {
+    name: "getProposal",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "proposalId", type: "uint256" }],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        components: [
+          { name: "id", type: "uint256" },
+          { name: "proposer", type: "address" },
+          { name: "vault", type: "address" },
+          { name: "strategy", type: "address" },
+          { name: "metadataURI", type: "string" },
+          { name: "performanceFeeBps", type: "uint256" },
+          { name: "strategyDuration", type: "uint256" },
+          { name: "votesFor", type: "uint256" },
+          { name: "votesAgainst", type: "uint256" },
+          { name: "votesAbstain", type: "uint256" },
+          { name: "snapshotTimestamp", type: "uint256" },
+          { name: "voteEnd", type: "uint256" },
+          { name: "reviewEnd", type: "uint256" },
+          { name: "executeBy", type: "uint256" },
+          { name: "executedAt", type: "uint256" },
+          { name: "state", type: "uint8" },
+          { name: "vetoThresholdBps", type: "uint256" },
+          // This tail was doubly stale: it omitted the fee-recipient snapshot
+          // entirely AND still carried `selfManagesFees`, which was removed.
+          // Every field is positional, so the first divergence corrupts the
+          // decode of everything after it.
+          { name: "snapshotProtocolFeeRecipient", type: "address" },
+          { name: "snapshotGuardiansFeeRecipient", type: "address" },
+          { name: "maxCapital", type: "uint256" },
+          { name: "maxDrawdownBps", type: "uint16" },
+          { name: "envelopeTier", type: "uint8" },
+          { name: "requiredCoverage", type: "uint256" },
+          { name: "proposerBondWood", type: "uint256" },
+          { name: "proposerBondEscrow", type: "address" },
+          {
+            name: "snapshotMgmtSplit",
+            type: "tuple",
+            components: [
+              { name: "agentBps", type: "uint16" },
+              { name: "protocolBps", type: "uint16" },
+              { name: "guardianBps", type: "uint16" }
+            ]
+          },
+          {
+            name: "snapshotPerfSplit",
+            type: "tuple",
+            components: [
+              { name: "agentBps", type: "uint16" },
+              { name: "protocolBps", type: "uint16" },
+              { name: "guardianBps", type: "uint16" },
+              { name: "ownerBps", type: "uint16" }
+            ]
+          },
+          { name: "proposerBondLedger", type: "address" },
+          { name: "effectiveMaxCapital", type: "uint256" }
+        ]
+      }
+    ]
+  },
+  // sandboxPayload — ISyndicateGovernor.sol ~730 / SyndicateGovernor.sol:506.
+  // Returns SandboxPayload {funding, calls, declaredTokens}. Calls are
+  // ICallSandbox.Call = (address target, bytes data) ONLY — no `value`.
+  // Non-sandbox (and unknown) pids return the mapping default: zero funding,
+  // empty calls, empty declaredTokens. The contract does not revert.
+  {
+    name: "sandboxPayload",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "proposalId", type: "uint256" }],
+    outputs: [
+      {
+        name: "payload",
+        type: "tuple",
+        components: [
+          { name: "funding", type: "uint256" },
+          {
+            name: "calls",
+            type: "tuple[]",
+            components: [
+              { name: "target", type: "address" },
+              { name: "data", type: "bytes" }
+            ]
+          },
+          { name: "declaredTokens", type: "address[]" }
+        ]
+      }
+    ]
+  },
+  {
+    name: "getProposalState",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "proposalId", type: "uint256" }],
+    outputs: [{ name: "", type: "uint8" }]
+  },
+  {
+    name: "getActiveProposal",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "proposalCount",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "getGovernorParams",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        components: [
+          { name: "votingPeriod", type: "uint256" },
+          { name: "executionWindow", type: "uint256" },
+          { name: "vetoThresholdBps", type: "uint256" },
+          { name: "maxPerformanceFeeBps", type: "uint256" },
+          { name: "cooldownPeriod", type: "uint256" },
+          { name: "collaborationWindow", type: "uint256" },
+          { name: "maxCoProposers", type: "uint256" },
+          { name: "minStrategyDuration", type: "uint256" },
+          { name: "maxStrategyDuration", type: "uint256" }
+        ]
+      }
+    ]
+  },
+  {
+    name: "protocolFeeRecipient",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }]
+  },
+  {
+    name: "FeeClamped",
+    type: "event",
+    inputs: [
+      { name: "proposalId", type: "uint256", indexed: true },
+      { name: "snapshotted", type: "uint256", indexed: true },
+      { name: "clamped", type: "uint256", indexed: true }
+    ]
+  }
+];
+var SYNDICATE_FACTORY_ABI = [
+  {
+    name: "createSyndicate",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "creatorAgentId", type: "uint256" },
+      {
+        name: "config",
+        type: "tuple",
+        components: [
+          { name: "metadataURI", type: "string" },
+          { name: "asset", type: "address" },
+          { name: "name", type: "string" },
+          { name: "symbol", type: "string" },
+          { name: "openDeposits", type: "bool" },
+          { name: "subdomain", type: "string" }
+        ]
+      }
+    ],
+    outputs: [
+      { name: "syndicateId", type: "uint256" },
+      { name: "vault", type: "address" }
+    ]
+  },
+  {
+    name: "syndicateCount",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "governorOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "vault", type: "address" }],
+    outputs: [{ name: "", type: "address" }]
+  },
+  {
+    name: "protocolConfig",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }]
+  },
+  {
+    name: "subdomainToSyndicate",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "subdomain", type: "string" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "vaultToSyndicate",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "vault", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "syndicates",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "id", type: "uint256" }],
+    outputs: [
+      { name: "id", type: "uint256" },
+      { name: "vault", type: "address" },
+      { name: "creator", type: "address" },
+      { name: "metadataURI", type: "string" },
+      { name: "createdAt", type: "uint256" },
+      { name: "active", type: "bool" },
+      { name: "subdomain", type: "string" }
+    ]
+  },
+  {
+    name: "getAllActiveSyndicates",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "tuple[]",
+        components: [
+          { name: "id", type: "uint256" },
+          { name: "vault", type: "address" },
+          { name: "creator", type: "address" },
+          { name: "metadataURI", type: "string" },
+          { name: "createdAt", type: "uint256" },
+          { name: "active", type: "bool" },
+          { name: "subdomain", type: "string" }
+        ]
+      }
+    ]
+  }
+];
+var PROTOCOL_CONFIG_ABI = [
+  {
+    name: "protocolFeeBps",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "guardianFeeBps",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "protocolFeeRecipient",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }]
+  },
+  // Protocol-owner setter — protocolFeeBps lives here, not on the governor.
+  {
+    name: "setProtocolFeeBps",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "newValue", type: "uint256" }],
+    outputs: []
+  }
+];
+var GUARDIAN_REGISTRY_ABI = [
+  // Guardian stake
+  {
+    name: "stakeAsGuardian",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "amount", type: "uint256" },
+      { name: "agentId", type: "uint256" }
+    ],
+    outputs: []
+  },
+  {
+    name: "requestUnstakeGuardian",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [],
+    outputs: []
+  },
+  {
+    name: "cancelUnstakeGuardian",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [],
+    outputs: []
+  },
+  {
+    name: "claimUnstakeGuardian",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [],
+    outputs: []
+  },
+  // Delegation and commission fragments removed (SHE-86): delegateStake,
+  // requestUnstakeDelegation, cancelUnstakeDelegation, claimUnstakeDelegation
+  // and setCommission do not exist on the post-audit contracts.
+  // Reads
+  {
+    name: "guardianStake",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "guardian", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "isActiveGuardian",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "guardian", type: "address" }],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  // Guardian review vote — 3 args, no slashBps. Selector 0x3ad95b6d.
+  // GuardianVoteType: None=0, Approve=1, Block=2 (uint8).
+  {
+    name: "voteOnProposal",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "governor", type: "address" },
+      { name: "proposalId", type: "uint256" },
+      { name: "support", type: "uint8" }
+    ],
+    outputs: []
+  },
+  // Cached review flags. Returns THREE bools (opened, resolved, blocked).
+  // A fourth output is the SHE-88 arity break: viem refuses the 96-byte returndata.
+  {
+    name: "getReviewState",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "governor", type: "address" },
+      { name: "proposalId", type: "uint256" }
+    ],
+    outputs: [
+      { name: "opened", type: "bool" },
+      { name: "resolved", type: "bool" },
+      { name: "blocked", type: "bool" }
+    ]
+  }
+];
+var STAKED_WOOD_ABI = [
+  {
+    name: "stakeAsGuardian",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "amount", type: "uint256" },
+      { name: "agentId", type: "uint256" }
+    ],
+    outputs: []
+  }
+];
+var ERC20_ABI = [
+  {
+    name: "approve",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    name: "allowance",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "balanceOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "decimals",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint8" }]
+  },
+  {
+    name: "symbol",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }]
+  }
+];
+var IDENTITY_REGISTRY_ABI = [
+  {
+    name: "register",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "agentURI", type: "string" },
+      {
+        name: "metadata",
+        type: "tuple[]",
+        components: [
+          { name: "metadataKey", type: "string" },
+          { name: "metadataValue", type: "bytes" }
+        ]
+      }
+    ],
+    outputs: [{ name: "agentId", type: "uint256" }]
+  }
+];
+var EAS_ABI = [
+  {
+    name: "attest",
+    type: "function",
+    stateMutability: "payable",
+    inputs: [
+      {
+        name: "request",
+        type: "tuple",
+        components: [
+          { name: "schema", type: "bytes32" },
+          {
+            name: "data",
+            type: "tuple",
+            components: [
+              { name: "recipient", type: "address" },
+              { name: "expirationTime", type: "uint64" },
+              { name: "revocable", type: "bool" },
+              { name: "refUID", type: "bytes32" },
+              { name: "data", type: "bytes" },
+              { name: "value", type: "uint256" }
+            ]
+          }
+        ]
+      }
+    ],
+    outputs: [{ name: "", type: "bytes32" }]
+  }
+];
+var STRATEGY_FACTORY_ABI = [
+  {
+    name: "cloneAndInit",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "template", type: "address" },
+      { name: "vault", type: "address" },
+      { name: "proposer", type: "address" },
+      { name: "data", type: "bytes" }
+    ],
+    outputs: [{ name: "clone", type: "address" }]
+  },
+  {
+    name: "cloneAndInitDeterministic",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "template", type: "address" },
+      { name: "vault", type: "address" },
+      { name: "proposer", type: "address" },
+      { name: "data", type: "bytes" },
+      { name: "salt", type: "bytes32" }
+    ],
+    outputs: [{ name: "clone", type: "address" }]
+  },
+  {
+    name: "syndicateFactory",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }]
+  }
+];
+
+// ../sdk/dist/addresses.js
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var ZERO_BYTES32 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var NO_GUARDIAN_ERA = {
+  governorBeacon: ZERO_ADDRESS,
+  protocolConfig: ZERO_ADDRESS,
+  priceRouter: ZERO_ADDRESS,
+  tierRegistry: ZERO_ADDRESS,
+  callSandboxImpl: ZERO_ADDRESS,
+  exposureLedger: ZERO_ADDRESS,
+  proposerBondEscrow: ZERO_ADDRESS,
+  challengeGame: ZERO_ADDRESS,
+  tokenCourt: ZERO_ADDRESS
+};
+var BASE_EAS = {
+  chainId: CHAIN_IDS.BASE,
+  address: "0x4200000000000000000000000000000000000021",
+  schemas: {
+    joinRequest: "0x1e7ce17b16233977ba913b156033e98f52029f4bee273a4abefe6c15ce11d5ef",
+    agentApproved: "0x1013f7b38f433b2a93fc5ac162482813081c64edd67cea9b5a90698531ddb607"
+  }
+};
+var NO_EAS = {
+  chainId: CHAIN_IDS.BASE,
+  address: ZERO_ADDRESS,
+  schemas: { joinRequest: ZERO_BYTES32, agentApproved: ZERO_BYTES32 }
+};
+var ROBINHOOD_EAS = {
+  chainId: CHAIN_IDS.ROBINHOOD,
+  address: "0x7d70441Bb10AcE5d9771dc0b6205D89ddf63205B",
+  schemas: {
+    joinRequest: "0x1e7ce17b16233977ba913b156033e98f52029f4bee273a4abefe6c15ce11d5ef",
+    agentApproved: "0x1013f7b38f433b2a93fc5ac162482813081c64edd67cea9b5a90698531ddb607"
+  }
+};
+var BASE = {
+  chainId: CHAIN_IDS.BASE,
+  name: "Base",
+  slug: "base",
+  sherwood: {
+    factory: "0xAC74EC56858d7F1f7618c8e77F65Fc26aDf33c82",
+    guardianRegistry: "0x49E4163b5e4b23F8f3d469Cf6fa197FB6b06A26E",
+    stakedWood: ZERO_ADDRESS,
+    // not in chains/8453.json
+    vaultImpl: "0xfce4bcE08E9C047E4736f75C2B8557e2754Ce36A",
+    batchExecutorLib: "0xbC79FbD5036C1Cc4A9d10BDf8628BF09a558496E",
+    // Not yet deployed on Base — fill in `STRATEGY_FACTORY` from
+    // contracts/chains/8453.json when it lands (issue #387).
+    strategyFactory: ZERO_ADDRESS,
+    // None of the guardian-era contracts are in chains/8453.json yet.
+    ...NO_GUARDIAN_ERA
+  },
+  identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
+  eas: BASE_EAS,
+  tokens: {
+    usdc: {
+      address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+      symbol: "USDC",
+      decimals: 6
+    },
+    weth: {
+      address: "0x4200000000000000000000000000000000000006",
+      symbol: "WETH",
+      decimals: 18
+    }
+  },
+  explorer: "https://basescan.org",
+  rpcs: ["https://mainnet.base.org"]
+};
+var HYPEREVM = {
+  chainId: CHAIN_IDS.HYPEREVM,
+  name: "HyperEVM",
+  slug: "hyperevm",
+  sherwood: {
+    factory: "0xd05Ae0E8bcf13075C29817c805d6Cc14F214393a",
+    guardianRegistry: "0x8b5710EB4e2fA639F364Dcc3F3B30c8f12F460b9",
+    stakedWood: ZERO_ADDRESS,
+    // no known sWOOD deployment
+    vaultImpl: "0x2cbBe36Cf907A2BB410bacB0e4Fd632C7b012846",
+    batchExecutorLib: "0x2c454bEF1b09c8a306a7058b8B510bF0DfF7179D",
+    strategyFactory: ZERO_ADDRESS,
+    // No canonical chain book for HyperEVM — guardian-era contracts unknown.
+    ...NO_GUARDIAN_ERA
+  },
+  // ERC-8004 identity is minted on Base; HyperEVM funds reference the
+  // Base-minted token id. Coordination attestations are pinned to Base EAS.
+  identityRegistry: ZERO_ADDRESS,
+  eas: BASE_EAS,
+  tokens: {
+    usdc: {
+      address: "0xb88339CB7199b77E23DB6E890353E22632Ba630f",
+      symbol: "USDC",
+      decimals: 6
+    }
+  },
+  explorer: "https://hyperliquid.cloud.blockscout.com",
+  rpcs: ["https://rpc.hyperliquid.xyz/evm"]
+};
+var ROBINHOOD = {
+  chainId: CHAIN_IDS.ROBINHOOD,
+  name: "Robinhood Chain",
+  slug: "robinhood",
+  sherwood: {
+    factory: ZERO_ADDRESS,
+    guardianRegistry: ZERO_ADDRESS,
+    stakedWood: ZERO_ADDRESS,
+    // 4663.json has WOOD, no STAKED_WOOD
+    vaultImpl: ZERO_ADDRESS,
+    batchExecutorLib: ZERO_ADDRESS,
+    strategyFactory: ZERO_ADDRESS,
+    // Sherwood not deployed on Robinhood mainnet — no guardian-era contracts.
+    ...NO_GUARDIAN_ERA
+  },
+  // Canonical ERC-8004 IdentityRegistry (verified on-chain — ERC-1967 proxy,
+  // name() = "AgentIdentity"). 4663 is the identity COORDINATION chain the
+  // same way it is the EAS one: agents mint here regardless of fund chain.
+  identityRegistry: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
+  eas: ROBINHOOD_EAS,
+  tokens: {
+    weth: {
+      address: "0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73",
+      symbol: "WETH",
+      decimals: 18
+    }
+  },
+  explorer: "https://robinhoodchain.blockscout.com",
+  rpcs: ["https://rpc.mainnet.chain.robinhood.com"]
+};
+var ROBINHOOD_L2 = {
+  chainId: CHAIN_IDS.ROBINHOOD_L2,
+  name: "Robinhood L2 Testnet",
+  slug: "robinhood-l2",
+  // V2 redeploy (chain 46630): fresh core contracts + a full guardian layer
+  // (registry + sWOOD) and a deployed StrategyFactory for the keyless
+  // clone+init path (#387). Post-#421 per-vault-governor redeploy — kept in
+  // sync with the canonical source of truth contracts/chains/46630.json (and
+  // the app's app/src/lib/contracts.ts ROBINHOOD_TESTNET_ADDRESSES). A stale
+  // factory here made /api/v1/funds?chain=46630 read the old deployment and
+  // return {count: 0} while the UI listed funds (issue #459).
+  sherwood: {
+    factory: "0xa91AA45AFF32f52b6357044B02a16EBA775feC0b",
+    guardianRegistry: "0xA400eFcfFc820C6f812203C58ee00423AeCC0903",
+    stakedWood: "0x21A69A6c9814c0d339C57fDdafed3B283702a739",
+    vaultImpl: "0xC57e12d6e2d8Ed49316F0b69c51893CcA44151F7",
+    batchExecutorLib: "0xF3b8db5aa41c7Ce92478A0Fa9C55a6460533eb86",
+    strategyFactory: "0xb683Bb8EEcBc2419BC3801df6FeA88f96657e670",
+    // Guardian-era contracts from contracts/chains/46630.json (SHE-93).
+    governorBeacon: "0x3D46Ec018cd5893b685b4dfdc3921A4Eb64E11d1",
+    protocolConfig: "0xC104Eb6a522d6718cA28F344B2373B29d57FF2E0",
+    priceRouter: "0xDd302ffcfA08071780eC1A2f12BccFB9ba6b6731",
+    tierRegistry: "0x99b8068Dc0F6093466964D581f72d947e3e380DB",
+    callSandboxImpl: "0xf09f6AF7DeBB964eD731376C9Af389F2Ce3d872A",
+    // Not in chains/46630.json (econ-security stack not deployed there yet).
+    exposureLedger: ZERO_ADDRESS,
+    proposerBondEscrow: ZERO_ADDRESS,
+    challengeGame: ZERO_ADDRESS,
+    tokenCourt: ZERO_ADDRESS
+  },
+  // No ERC-8004 registry on 46630. Attestations for funds here are recorded on
+  // the 4663 coordination chain, so this points at the SAME deployment — note
+  // eas.chainId is 4663, not this chain's id. That is deliberate.
+  identityRegistry: ZERO_ADDRESS,
+  eas: ROBINHOOD_EAS,
+  tokens: {
+    wood: {
+      address: "0xCCb4fB59cf40de1E23083037ee81Da1DD747D8d7",
+      symbol: "WOOD",
+      decimals: 18
+    }
+  },
+  explorer: "https://explorer.testnet.chain.robinhood.com",
+  rpcs: ["https://rpc.testnet.chain.robinhood.com"]
+};
+var ROBINHOOD_FORK = {
+  chainId: CHAIN_IDS.ROBINHOOD_FORK,
+  name: "Robinhood Chain (fork)",
+  slug: "robinhood-fork",
+  sherwood: {
+    factory: "0x02bc9B9C1A4322D5A5df86DadA0a2a02e45108B9",
+    guardianRegistry: "0xdfEe38C4D7595c9c04AdBcaFE01E4Fd6FD6117f4",
+    stakedWood: "0xD3037D28693cc7BB3DbF1E17B6e01C4ce628f6DF",
+    vaultImpl: "0x9BF51da59B13746e6cCeb1b35c398EDA9776a4Dc",
+    batchExecutorLib: "0xdBdBce2af4222Abe0cCDAc05f84364a50577B5a2",
+    strategyFactory: "0xb3C009aECAeDd5ccC62Ec12eDAAA55F19C4A1eFb",
+    // Guardian-era contracts from sherwood-protocol/chains/9994663.json (SHE-93).
+    governorBeacon: "0x2e8aB422Db9127F1a70d8C38A15903f22B51DA97",
+    protocolConfig: "0x36C45dC52FbC267d8536E8456ADe5255eC83A5ab",
+    // Not in chains/9994663.json (no PriceRouter / CallSandbox on the fork).
+    priceRouter: ZERO_ADDRESS,
+    tierRegistry: "0x42B089B816F994d792481fAa308199E9CF63be9f",
+    callSandboxImpl: ZERO_ADDRESS,
+    exposureLedger: "0x223e2Fd41aD6487333146fc3998d000E74CB1549",
+    proposerBondEscrow: "0xef2D6994faCad11e6CfAF3DaBf7b0B2091009B05",
+    challengeGame: "0x202c1F133006D6706e872433CCAfD729c7A8AE56",
+    tokenCourt: "0x5DC603881f5d77f41bbd4202F1d518263Dfd497f"
+  },
+  // The fork is ephemeral, so attestation WRITES are disabled there (CLI
+  // enforces it). Reads still resolve against the 4663 coordination chain, so
+  // a fork session can display real attestations.
+  identityRegistry: ZERO_ADDRESS,
+  eas: ROBINHOOD_EAS,
+  tokens: {
+    weth: {
+      address: "0x0Bd7D308f8E1639FAb988df18A8011f41EAcAD73",
+      symbol: "WETH",
+      decimals: 18
+    },
+    wood: {
+      address: "0xF8BC08092C06dB6148114DCf82AF881F1085f92b",
+      symbol: "WOOD",
+      decimals: 18
+    }
+  },
+  // A Tenderly vnet scopes its blocks under /explorer/vnet/<id> — the bare
+  // dashboard host resolves to the caller's own dashboard, not this fork.
+  explorer: "https://dashboard.tenderly.co/explorer/vnet/6ad5961e-fbca-452f-939f-ca9a8c020933",
+  // PUBLIC endpoint of vnet a3fb16: reads + tx broadcast, no state-cheat
+  // surface. Admin/cheat RPCs stay private (Tenderly dashboard).
+  rpcs: [
+    "https://virtual.robinhood-chain.eu.rpc.tenderly.co/moonwell/wormhole-bridge/231af1"
+  ]
+};
+var REGISTRY = {
+  [CHAIN_IDS.BASE]: BASE,
+  [CHAIN_IDS.HYPEREVM]: HYPEREVM,
+  [CHAIN_IDS.ROBINHOOD]: ROBINHOOD,
+  [CHAIN_IDS.ROBINHOOD_L2]: ROBINHOOD_L2,
+  [CHAIN_IDS.ROBINHOOD_FORK]: ROBINHOOD_FORK
+};
+function getDeployment(chainId) {
+  const entry = REGISTRY[chainId];
+  if (!entry)
+    throw unsupported(`No Sherwood deployment for chain ${chainId}`);
+  return entry;
+}
+
+// ../sdk/dist/encoders/vault.js
+import { encodeFunctionData, getAddress, maxUint256 } from "viem";
+var WETH_ABI = [
+  {
+    name: "deposit",
+    type: "function",
+    stateMutability: "payable",
+    inputs: [],
+    outputs: []
+  }
+];
+var ZERO_VALUE = "0x0";
+function toHexValue(value) {
+  return `0x${value.toString(16)}`;
+}
+function encodeApproveTx(token, spender, amount, chainId) {
+  return {
+    to: token,
+    data: encodeFunctionData({
+      abi: ERC20_ABI,
+      functionName: "approve",
+      args: [spender, amount]
+    }),
+    value: ZERO_VALUE,
+    chainId
+  };
+}
+function encodeDepositTx(vault, assets, receiver, chainId) {
+  return {
+    to: vault,
+    data: encodeFunctionData({
+      abi: SYNDICATE_VAULT_ABI,
+      functionName: "deposit",
+      args: [assets, receiver]
+    }),
+    value: ZERO_VALUE,
+    chainId
+  };
+}
+function encodeDeposit(args, chainId) {
+  if (args.assets <= 0n) {
+    throw usage("`assets` must be > 0");
+  }
+  const vault = getAddress(args.vault);
+  const receiver = getAddress(args.receiver);
+  const asset = getAddress(args.asset);
+  const txs = [];
+  let wrapped = false;
+  if (args.wrapEth) {
+    const weth = getDeployment(chainId).tokens.weth;
+    if (!weth || getAddress(weth.address) !== asset) {
+      throw usage("`wrapEth` is only valid for WETH vaults \u2014 the vault asset must be the chain's WETH.");
+    }
+    const held = args.currentWethBalance ?? 0n;
+    const shortfall = held >= args.assets ? 0n : args.assets - held;
+    if (shortfall > 0n) {
+      txs.push({
+        to: asset,
+        data: encodeFunctionData({ abi: WETH_ABI, functionName: "deposit", args: [] }),
+        value: toHexValue(shortfall),
+        chainId
+      });
+      wrapped = true;
+    }
+  }
+  const needsApprove = args.currentAllowance === void 0 || args.currentAllowance < args.assets;
+  if (needsApprove) {
+    txs.push(encodeApproveTx(asset, vault, maxUint256, chainId));
+  }
+  txs.push(encodeDepositTx(vault, args.assets, receiver, chainId));
+  const minDecimal = formatUnits(args.assets, args.assetDecimals);
+  let description;
+  if (wrapped) {
+    description = needsApprove ? `Wrap ETH\u2192WETH, approve ${args.assetSymbol} for ${vault}, then deposit ${minDecimal} ${args.assetSymbol}.` : `Wrap ETH\u2192WETH, then deposit ${minDecimal} ${args.assetSymbol}.`;
+  } else {
+    description = needsApprove ? `Approve ${args.assetSymbol} for ${vault}, then deposit ${minDecimal} ${args.assetSymbol}.` : `Deposit ${minDecimal} ${args.assetSymbol} into ${vault}.`;
+  }
+  return {
+    txs,
+    preconditions: [
+      {
+        type: "balance",
+        asset,
+        assetSymbol: args.assetSymbol,
+        min: args.assets.toString(),
+        minDecimal
+      },
+      {
+        type: "allowance",
+        token: asset,
+        spender: vault,
+        min: args.assets.toString(),
+        minDecimal
+      },
+      { type: "vault-not-locked", vault },
+      { type: "depositor-approved", vault, depositor: receiver }
+    ],
+    description,
+    note: "Both txs are gated by vault state. If `redemptionsLocked()` is true the deposit reverts unless live NAV is available; check the vault read endpoint before broadcasting."
+  };
+}
+function formatUnits(value, decimals) {
+  if (decimals === 0)
+    return value.toString();
+  const negative = value < 0n;
+  const abs = negative ? -value : value;
+  const str = abs.toString().padStart(decimals + 1, "0");
+  const head = str.slice(0, str.length - decimals);
+  const tail = str.slice(str.length - decimals).replace(/0+$/, "");
+  const out = tail.length > 0 ? `${head}.${tail}` : head;
+  return negative ? `-${out}` : out;
+}
+function encodeRedeem(args, chainId) {
+  if (args.shares <= 0n)
+    throw usage("`shares` must be > 0");
+  const vault = getAddress(args.vault);
+  const receiver = getAddress(args.receiver);
+  const owner = getAddress(args.owner);
+  return {
+    txs: [
+      {
+        to: vault,
+        data: encodeFunctionData({
+          abi: SYNDICATE_VAULT_ABI,
+          functionName: "redeem",
+          args: [args.shares, receiver, owner]
+        }),
+        value: ZERO_VALUE,
+        chainId
+      }
+    ],
+    preconditions: [
+      { type: "vault-not-locked", vault }
+    ],
+    description: `Redeem ${args.shares.toString()} shares of ${vault} \u2192 ${receiver}.`,
+    note: "Synchronous path. Reverts if the vault has an active proposal AND live NAV is unavailable; in that case use /prepare/request-redeem (queue path) instead."
+  };
+}
+function encodeApproveDepositor(args, chainId) {
+  const vault = getAddress(args.vault);
+  const depositor = getAddress(args.depositor);
+  return {
+    txs: [
+      {
+        to: vault,
+        data: encodeFunctionData({
+          abi: SYNDICATE_VAULT_ABI,
+          functionName: "approveDepositor",
+          args: [depositor]
+        }),
+        value: ZERO_VALUE,
+        chainId
+      }
+    ],
+    preconditions: [],
+    description: `Approve depositor ${depositor} on vault ${vault}.`,
+    note: "Vault owner only."
+  };
+}
+function encodeRegisterAgent(args, chainId) {
+  const vault = getAddress(args.vault);
+  const agentAddress = getAddress(args.agentAddress);
+  const id = typeof args.agentId === "bigint" ? args.agentId : BigInt(args.agentId);
+  if (id < 0n)
+    throw usage("`agentId` must be a non-negative integer");
+  return {
+    txs: [
+      {
+        to: vault,
+        data: encodeFunctionData({
+          abi: SYNDICATE_VAULT_ABI,
+          functionName: "registerAgent",
+          args: [agentAddress, id]
+        }),
+        value: ZERO_VALUE,
+        chainId
+      }
+    ],
+    preconditions: [],
+    description: `Register agent ${agentAddress} (id ${id.toString()}) on vault ${vault}.`,
+    note: "Vault owner only. The ERC-8004 NFT must be owned by `agentAddress` or by the vault owner at registration time."
+  };
+}
+
+// ../sdk/dist/encoders/governor.js
+import { encodeFunctionData as encodeFunctionData2, getAddress as getAddress2, isAddress as isAddress2 } from "viem";
+var ZERO_VALUE2 = "0x0";
+var VOTE_TYPES = {
+  For: 0,
+  Against: 1,
+  Abstain: 2
+};
+function governorTx(governor, chainId, data) {
+  return {
+    to: governor,
+    data,
+    value: ZERO_VALUE2,
+    chainId
+  };
+}
+function parseGovernor(value) {
+  if (typeof value !== "string" || !isAddress2(value)) {
+    throw usage("`governor` must be the vault's governor address \u2014 resolve it with `resolveGovernor(client, chainId, vault)` (factory.governorOf)");
+  }
+  return getAddress2(value);
+}
+function parseProposalId(value) {
+  if (typeof value === "bigint") {
+    if (value < 0n)
+      throw usage("`proposalId` must be a non-negative integer");
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isInteger(value) || value < 0) {
+      throw usage("`proposalId` must be a non-negative integer");
+    }
+    return BigInt(value);
+  }
+  if (!/^\d+$/.test(value)) {
+    throw usage(`\`proposalId\` must be a non-negative integer string, got "${value}"`);
+  }
+  return BigInt(value);
+}
+function encodeVote(args, chainId) {
+  const governor = parseGovernor(args.governor);
+  const support = VOTE_TYPES[args.vote];
+  if (support === void 0) {
+    throw usage(`Unsupported vote "${args.vote}" \u2014 must be one of: ${Object.keys(VOTE_TYPES).join(", ")}`);
+  }
+  const proposalId = parseProposalId(args.proposalId);
+  const data = encodeFunctionData2({
+    abi: SYNDICATE_GOVERNOR_ABI,
+    functionName: "vote",
+    args: [proposalId, support]
+  });
+  return {
+    txs: [governorTx(governor, chainId, data)],
+    preconditions: [],
+    description: `Vote ${args.vote} on proposal ${proposalId.toString()}.`,
+    note: "Voter must hold ERC20Votes shares of the vault at the proposal's snapshot timestamp; double-voting reverts. Use the proposal read endpoint to check `voteEnd` first."
+  };
+}
+function lifecycleAction(fn, proposalId, governor, chainId, description, note) {
+  const data = encodeFunctionData2({
+    abi: SYNDICATE_GOVERNOR_ABI,
+    functionName: fn,
+    args: [proposalId]
+  });
+  return {
+    txs: [governorTx(governor, chainId, data)],
+    preconditions: [],
+    description,
+    note
+  };
+}
+function encodeExecute(args, chainId) {
+  const id = parseProposalId(args.proposalId);
+  return lifecycleAction("executeProposal", id, parseGovernor(args.governor), chainId, `Execute proposal ${id.toString()} (open the strategy).`, "Reverts if the proposal is not in the `Approved` state. Check `state == Approved` via the proposal read endpoint first.");
+}
+function encodeSettle(args, chainId) {
+  const id = parseProposalId(args.proposalId);
+  return lifecycleAction("settleProposal", id, parseGovernor(args.governor), chainId, `Settle proposal ${id.toString()} (close the strategy and distribute fees).`, "Proposer can settle anytime; anyone can settle after the strategy duration elapses.");
+}
+function encodeCancel(args, chainId) {
+  const id = parseProposalId(args.proposalId);
+  return lifecycleAction("cancelProposal", id, parseGovernor(args.governor), chainId, `Cancel proposal ${id.toString()} (proposer-only).`, "Only the proposer can cancel, and only while the proposal is in `Pending`, `GuardianReview`, or `Approved`.");
+}
+function toBigInt(v, label) {
+  if (typeof v === "bigint")
+    return v;
+  if (typeof v === "number" && Number.isInteger(v) && v >= 0)
+    return BigInt(v);
+  if (typeof v === "string" && /^\d+$/.test(v))
+    return BigInt(v);
+  throw usage(`\`${label}\` must be a non-negative integer (string, number, or bigint)`);
+}
+function validateCaps(caps, calls, maxCapital, scope) {
+  if (!Array.isArray(caps)) {
+    throw usage(`\`${scope}\` must be an array of per-call caps, one per call`);
+  }
+  if (caps.length !== calls.length) {
+    throw usage(`\`${scope}\` has ${caps.length} entries for ${calls.length} calls \u2014 every call must declare exactly one cap`);
+  }
+  const out = caps.map((c, i) => toBigInt(c, `${scope}[${i}]`));
+  const sum = out.reduce((a, b) => a + b, 0n);
+  if (sum > maxCapital) {
+    throw usage(`\`${scope}\` sums to ${sum} which exceeds \`envelope.maxCapital\` (${maxCapital})`);
+  }
+  return out;
+}
+var ZERO_ADDRESS2 = "0x0000000000000000000000000000000000000000";
+function validateBatchCall(call, scope, idx) {
+  if (!call || typeof call !== "object") {
+    throw usage(`\`${scope}[${idx}]\` must be an object`);
+  }
+  const c = call;
+  if (typeof c.target !== "string" || !isAddress2(c.target)) {
+    throw usage(`\`${scope}[${idx}].target\` must be a 0x-prefixed address`);
+  }
+  if (typeof c.data !== "string" || !/^0x[0-9a-fA-F]*$/.test(c.data)) {
+    throw usage(`\`${scope}[${idx}].data\` must be a 0x-prefixed hex string`);
+  }
+  let value;
+  if (typeof c.value === "string") {
+    if (!/^\d+$/.test(c.value)) {
+      throw usage(`\`${scope}[${idx}].value\` must be a non-negative integer string`);
+    }
+    value = BigInt(c.value);
+  } else if (typeof c.value === "bigint") {
+    if (c.value < 0n) {
+      throw usage(`\`${scope}[${idx}].value\` must be non-negative`);
+    }
+    value = c.value;
+  } else if (c.value === void 0 || c.value === null) {
+    value = 0n;
+  } else {
+    throw usage(`\`${scope}[${idx}].value\` must be a non-negative integer string (or omitted for 0)`);
+  }
+  return { target: getAddress2(c.target), data: c.data, value };
+}
+function encodePropose(args, chainId) {
+  const vault = getAddress2(args.vault);
+  const governor = parseGovernor(args.governor);
+  const strategy = args.strategy === ZERO_ADDRESS2 ? ZERO_ADDRESS2 : getAddress2(args.strategy);
+  if (typeof args.metadataURI !== "string" || args.metadataURI.length === 0) {
+    throw usage("`metadataURI` must be a non-empty string (e.g. ipfs://...)");
+  }
+  const strategyDuration = typeof args.strategyDuration === "bigint" ? args.strategyDuration : BigInt(args.strategyDuration);
+  if (strategyDuration <= 0n) {
+    throw usage("`strategyDuration` must be > 0 (seconds)");
+  }
+  if (!Array.isArray(args.executeCalls)) {
+    throw usage("`executeCalls` must be an array of {target, data, value} objects");
+  }
+  if (!Array.isArray(args.settlementCalls)) {
+    throw usage("`settlementCalls` must be an array of {target, data, value} objects");
+  }
+  const executeCalls = args.executeCalls.map((c, i) => validateBatchCall(c, "executeCalls", i));
+  const settlementCalls = args.settlementCalls.map((c, i) => validateBatchCall(c, "settlementCalls", i));
+  const coProposers = (args.coProposers ?? []).map((cp, i) => {
+    if (!cp || typeof cp !== "object") {
+      throw usage(`\`coProposers[${i}]\` must be an object`);
+    }
+    const agent = cp.agent;
+    const splitBps = cp.splitBps;
+    if (typeof agent !== "string" || !isAddress2(agent)) {
+      throw usage(`\`coProposers[${i}].agent\` must be a 0x-prefixed address`);
+    }
+    let bps;
+    if (typeof splitBps === "string" && /^\d+$/.test(splitBps)) {
+      bps = BigInt(splitBps);
+    } else if (typeof splitBps === "bigint") {
+      bps = splitBps;
+    } else if (typeof splitBps === "number" && Number.isInteger(splitBps) && splitBps >= 0) {
+      bps = BigInt(splitBps);
+    } else {
+      throw usage(`\`coProposers[${i}].splitBps\` must be a non-negative integer (string, number, or bigint)`);
+    }
+    if (bps < 0n || bps > 10000n) {
+      throw usage(`\`coProposers[${i}].splitBps\` must be in [0, 10000]`);
+    }
+    return { agent: getAddress2(agent), splitBps: bps };
+  });
+  if (!args.envelope || typeof args.envelope !== "object") {
+    throw usage("`envelope` must be an object of {maxCapital, maxDrawdownBps}");
+  }
+  const maxCapital = toBigInt(args.envelope.maxCapital, "envelope.maxCapital");
+  if (maxCapital === 0n) {
+    throw usage("`envelope.maxCapital` must be > 0 (the governor rejects zero as ZeroMaxCapital)");
+  }
+  const maxDrawdownBps = args.envelope.maxDrawdownBps;
+  if (!Number.isInteger(maxDrawdownBps) || maxDrawdownBps < 0 || maxDrawdownBps > 1e4) {
+    throw usage("`envelope.maxDrawdownBps` must be an integer in [0, 10000]");
+  }
+  const executeCallCaps = validateCaps(args.executeCallCaps, executeCalls, maxCapital, "executeCallCaps");
+  const settlementCallCaps = validateCaps(args.settlementCallCaps, settlementCalls, maxCapital, "settlementCallCaps");
+  const data = encodeFunctionData2({
+    abi: SYNDICATE_GOVERNOR_ABI,
+    functionName: "propose",
+    args: [
+      vault,
+      strategy,
+      args.metadataURI,
+      strategyDuration,
+      { maxCapital, maxDrawdownBps },
+      executeCalls,
+      executeCallCaps,
+      settlementCalls,
+      settlementCallCaps,
+      coProposers
+    ]
+  });
+  return {
+    txs: [governorTx(governor, chainId, data)],
+    preconditions: [
+      { type: "vault-not-locked", vault }
+    ],
+    description: `Propose a strategy on ${vault} (duration ${strategyDuration.toString()}s). Agent fee is snapshotted from the vault's agentFeeBps at propose time, then clamped to maxPerformanceFeeBps at settlement.`,
+    note: "Reverts if the vault has an active proposal (cooldown not elapsed). The strategy address is immutable post-propose; pass address(0) to opt out of live NAV. `coProposers[].splitBps` total must satisfy contract-side constraints."
+  };
+}
+var MAX_SANDBOX_CALLS = 32;
+var MAX_SANDBOX_TOKENS = 16;
+function validateSandboxCall(call, idx) {
+  if (!call || typeof call !== "object") {
+    throw usage(`\`sandbox.calls[${idx}]\` must be an object of {target, data}`);
+  }
+  const c = call;
+  if ("value" in c && c.value !== void 0 && c.value !== null) {
+    throw usage(`\`sandbox.calls[${idx}]\` must be (address,bytes) only \u2014 ICallSandbox.Call has no \`value\` field (native value would open an unmetered transfer channel). Do not alias BatchExecutorLib.Call.`);
+  }
+  if (typeof c.target !== "string" || !isAddress2(c.target)) {
+    throw usage(`\`sandbox.calls[${idx}].target\` must be a 0x-prefixed address`);
+  }
+  if (getAddress2(c.target) === ZERO_ADDRESS2) {
+    throw usage(`\`sandbox.calls[${idx}].target\` must not be the zero address (the governor reverts ZeroSandboxTarget)`);
+  }
+  if (typeof c.data !== "string" || !/^0x[0-9a-fA-F]*$/.test(c.data)) {
+    throw usage(`\`sandbox.calls[${idx}].data\` must be a 0x-prefixed hex string`);
+  }
+  return { target: getAddress2(c.target), data: c.data };
+}
+function validateSandboxPayload(sandbox, maxCapital) {
+  if (!sandbox || typeof sandbox !== "object") {
+    throw usage("`sandbox` must be an object of {funding, calls, declaredTokens}");
+  }
+  const s = sandbox;
+  const funding = toBigInt(s.funding, "sandbox.funding");
+  if (funding === 0n) {
+    throw usage("`sandbox.funding` must be > 0 (the governor rejects zero as ZeroSandboxFunding)");
+  }
+  if (funding > maxCapital) {
+    throw usage(`\`sandbox.funding\` (${funding}) exceeds \`envelope.maxCapital\` (${maxCapital}) \u2014 the sandbox is funded out of the declared envelope, not beside it`);
+  }
+  if (!Array.isArray(s.calls)) {
+    throw usage("`sandbox.calls` must be an array of {target, data} objects (no value)");
+  }
+  if (s.calls.length === 0) {
+    throw usage("`sandbox.calls` must be non-empty (the governor rejects empty as EmptySandboxCalls)");
+  }
+  if (s.calls.length > MAX_SANDBOX_CALLS) {
+    throw usage(`\`sandbox.calls\` has ${s.calls.length} entries; max is ${MAX_SANDBOX_CALLS}`);
+  }
+  const calls = s.calls.map((c, i) => validateSandboxCall(c, i));
+  const rawTokens = s.declaredTokens ?? [];
+  if (!Array.isArray(rawTokens)) {
+    throw usage("`sandbox.declaredTokens` must be an array of addresses");
+  }
+  if (rawTokens.length > MAX_SANDBOX_TOKENS) {
+    throw usage(`\`sandbox.declaredTokens\` has ${rawTokens.length} entries; max is ${MAX_SANDBOX_TOKENS}`);
+  }
+  const declaredTokens = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let i = 0; i < rawTokens.length; i++) {
+    const t = rawTokens[i];
+    if (typeof t !== "string" || !isAddress2(t)) {
+      throw usage(`\`sandbox.declaredTokens[${i}]\` must be a 0x-prefixed address`);
+    }
+    const addr = getAddress2(t);
+    if (seen.has(addr.toLowerCase())) {
+      throw usage(`\`sandbox.declaredTokens[${i}]\` duplicates ${addr} (the governor reverts DuplicateSandboxToken)`);
+    }
+    seen.add(addr.toLowerCase());
+    declaredTokens.push(addr);
+  }
+  return { funding, calls, declaredTokens };
+}
+function encodeProposeWithSandbox(args, chainId) {
+  const vault = getAddress2(args.vault);
+  const governor = parseGovernor(args.governor);
+  const strategy = args.strategy === ZERO_ADDRESS2 ? ZERO_ADDRESS2 : getAddress2(args.strategy);
+  if (typeof args.metadataURI !== "string" || args.metadataURI.length === 0) {
+    throw usage("`metadataURI` must be a non-empty string (e.g. ipfs://...)");
+  }
+  const strategyDuration = typeof args.strategyDuration === "bigint" ? args.strategyDuration : BigInt(args.strategyDuration);
+  if (strategyDuration <= 0n) {
+    throw usage("`strategyDuration` must be > 0 (seconds)");
+  }
+  if (!Array.isArray(args.executeCalls)) {
+    throw usage("`executeCalls` must be an array of {target, data, value} objects");
+  }
+  if (!Array.isArray(args.settlementCalls)) {
+    throw usage("`settlementCalls` must be an array of {target, data, value} objects");
+  }
+  const executeCalls = args.executeCalls.map((c, i) => validateBatchCall(c, "executeCalls", i));
+  const settlementCalls = args.settlementCalls.map((c, i) => validateBatchCall(c, "settlementCalls", i));
+  const coProposers = (args.coProposers ?? []).map((cp, i) => {
+    if (!cp || typeof cp !== "object") {
+      throw usage(`\`coProposers[${i}]\` must be an object`);
+    }
+    const agent = cp.agent;
+    const splitBps = cp.splitBps;
+    if (typeof agent !== "string" || !isAddress2(agent)) {
+      throw usage(`\`coProposers[${i}].agent\` must be a 0x-prefixed address`);
+    }
+    let bps;
+    if (typeof splitBps === "string" && /^\d+$/.test(splitBps)) {
+      bps = BigInt(splitBps);
+    } else if (typeof splitBps === "bigint") {
+      bps = splitBps;
+    } else if (typeof splitBps === "number" && Number.isInteger(splitBps) && splitBps >= 0) {
+      bps = BigInt(splitBps);
+    } else {
+      throw usage(`\`coProposers[${i}].splitBps\` must be a non-negative integer (string, number, or bigint)`);
+    }
+    if (bps < 0n || bps > 10000n) {
+      throw usage(`\`coProposers[${i}].splitBps\` must be in [0, 10000]`);
+    }
+    return { agent: getAddress2(agent), splitBps: bps };
+  });
+  if (!args.envelope || typeof args.envelope !== "object") {
+    throw usage("`envelope` must be an object of {maxCapital, maxDrawdownBps}");
+  }
+  const maxCapital = toBigInt(args.envelope.maxCapital, "envelope.maxCapital");
+  if (maxCapital === 0n) {
+    throw usage("`envelope.maxCapital` must be > 0 (the governor rejects zero as ZeroMaxCapital)");
+  }
+  const maxDrawdownBps = args.envelope.maxDrawdownBps;
+  if (!Number.isInteger(maxDrawdownBps) || maxDrawdownBps < 0 || maxDrawdownBps > 1e4) {
+    throw usage("`envelope.maxDrawdownBps` must be an integer in [0, 10000]");
+  }
+  const executeCallCaps = validateCaps(args.executeCallCaps, executeCalls, maxCapital, "executeCallCaps");
+  const settlementCallCaps = validateCaps(args.settlementCallCaps, settlementCalls, maxCapital, "settlementCallCaps");
+  const sandbox = validateSandboxPayload(args.sandbox, maxCapital);
+  const data = encodeFunctionData2({
+    abi: SYNDICATE_GOVERNOR_ABI,
+    functionName: "proposeWithSandbox",
+    args: [
+      sandbox,
+      vault,
+      strategy,
+      args.metadataURI,
+      strategyDuration,
+      { maxCapital, maxDrawdownBps },
+      executeCalls,
+      executeCallCaps,
+      settlementCalls,
+      settlementCallCaps,
+      coProposers
+    ]
+  });
+  return {
+    txs: [governorTx(governor, chainId, data)],
+    preconditions: [
+      { type: "vault-not-locked", vault }
+    ],
+    description: `Propose a sandbox strategy on ${vault} (funding ${sandbox.funding.toString()}, ${sandbox.calls.length} sandbox call(s), duration ${strategyDuration.toString()}s).`,
+    note: "Reverts if the vault has an active proposal, has no CallSandbox implementation bound, or the payload fails propose-time sandbox gates (empty calls, zero funding, funding > maxCapital, zero target, duplicate declared tokens). ICallSandbox.Call is (address,bytes) only \u2014 no native value."
+  };
+}
+function encodeUnstick(args, chainId) {
+  const governor = parseGovernor(args.governor);
+  const id = parseProposalId(args.proposalId);
+  const data = encodeFunctionData2({
+    abi: SYNDICATE_GOVERNOR_ABI,
+    functionName: "unstick",
+    args: [id]
+  });
+  return {
+    txs: [governorTx(governor, chainId, data)],
+    preconditions: [],
+    description: `Unstick proposal ${id.toString()} \u2014 run its governance-approved settlement calls (owner-instant, no funds beyond the approved calls).`,
+    note: "Vault-owner only. Valid only when the proposal is Executed AND its strategy duration has elapsed. Runs the proposal's pre-committed settlement calls and finalizes settlement; no owner stake required. Reverts if those calls revert \u2014 if they can't succeed, open an emergency-settle with custom unwind calls instead."
+  };
+}
+function encodeEmergencySettle(args, chainId) {
+  const governor = parseGovernor(args.governor);
+  const id = parseProposalId(args.proposalId);
+  if (!Array.isArray(args.calls)) {
+    throw usage("`calls` must be an array of {target, data, value} objects");
+  }
+  const calls = args.calls.map((c, i) => validateBatchCall(c, "calls", i));
+  const data = encodeFunctionData2({
+    abi: SYNDICATE_GOVERNOR_ABI,
+    functionName: "emergencySettleWithCalls",
+    args: [id, calls]
+  });
+  return {
+    txs: [governorTx(governor, chainId, data)],
+    preconditions: [],
+    description: `Open an emergency-settle review on proposal ${id.toString()} with ${calls.length} unwind call(s).`,
+    note: "Vault-owner only, requires bonded owner stake. Does NOT execute immediately \u2014 it commits the calls' hash and opens a guardian-reviewed window (default ~24h). After the window, finalize with finalizeEmergencySettle; guardians can block within it (owner stake burned on block-quorum)."
+  };
+}
+function parseUintArg(value, label) {
+  if (typeof value === "bigint") {
+    if (value < 0n)
+      throw usage(`\`${label}\` must be a non-negative integer`);
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isInteger(value) || value < 0) {
+      throw usage(`\`${label}\` must be a non-negative integer`);
+    }
+    return BigInt(value);
+  }
+  if (!/^\d+$/.test(value)) {
+    throw usage(`\`${label}\` must be a non-negative integer string, got "${value}"`);
+  }
+  return BigInt(value);
+}
+var GOVERNOR_PARAM_SETTERS = {
+  votingPeriod: "setVotingPeriod",
+  executionWindow: "setExecutionWindow",
+  vetoThresholdBps: "setVetoThresholdBps",
+  maxPerformanceFeeBps: "setMaxPerformanceFeeBps",
+  maxStrategyDuration: "setMaxStrategyDuration",
+  cooldownPeriod: "setCooldownPeriod"
+};
+function encodeGovernorParam(args, chainId) {
+  const governor = parseGovernor(args.governor);
+  const fn = GOVERNOR_PARAM_SETTERS[args.param];
+  if (!fn) {
+    throw usage(`Unknown governor param "${args.param}" \u2014 must be one of: ${Object.keys(GOVERNOR_PARAM_SETTERS).join(", ")}`);
+  }
+  const value = parseUintArg(args.value, args.param);
+  const data = encodeFunctionData2({
+    abi: SYNDICATE_GOVERNOR_ABI,
+    functionName: fn,
+    args: [value]
+  });
+  return {
+    txs: [governorTx(governor, chainId, data)],
+    preconditions: [],
+    description: `Set governor parameter ${args.param} = ${value.toString()}.`,
+    note: "Vault-owner only. V1.5 has no on-chain parameter timelock \u2014 the change applies immediately on this call. Bounds are validated on-chain; out-of-range values revert."
+  };
+}
+function encodeProtocolFeeBps(args, chainId) {
+  if (!isAddress2(args.protocolConfig)) {
+    throw usage(`\`protocolConfig\` must be a valid address, got "${args.protocolConfig}"`);
+  }
+  const protocolConfig = getAddress2(args.protocolConfig);
+  const value = parseUintArg(args.value, "protocolFeeBps");
+  const data = encodeFunctionData2({
+    abi: PROTOCOL_CONFIG_ABI,
+    functionName: "setProtocolFeeBps",
+    args: [value]
+  });
+  return {
+    txs: [governorTx(protocolConfig, chainId, data)],
+    preconditions: [],
+    description: `Set ProtocolConfig protocolFeeBps = ${value.toString()}.`,
+    note: "Protocol-owner only (the protocol multisig), NOT the vault owner. Targets the protocol-wide ProtocolConfig contract. Bounds are validated on-chain; setting a non-zero protocolFeeBps reverts unless protocolFeeRecipient is already set."
+  };
+}
+
+// ../sdk/dist/encoders/factory.js
+import { encodeFunctionData as encodeFunctionData3, getAddress as getAddress3 } from "viem";
+var ZERO_VALUE3 = "0x0";
+var SUBDOMAIN_RE = /^[a-z0-9-]{1,63}$/;
+function encodeCreateFund(args, chainId) {
+  if (typeof args.metadataURI !== "string" || args.metadataURI.length === 0) {
+    throw usage("`metadataURI` must be a non-empty string (e.g. ipfs://...)");
+  }
+  if (typeof args.name !== "string" || args.name.length === 0) {
+    throw usage("`name` must be a non-empty string");
+  }
+  if (typeof args.symbol !== "string" || args.symbol.length === 0) {
+    throw usage("`symbol` must be a non-empty string");
+  }
+  if (typeof args.openDeposits !== "boolean") {
+    throw usage("`openDeposits` must be a boolean");
+  }
+  if (!SUBDOMAIN_RE.test(args.subdomain)) {
+    throw usage("`subdomain` must match /^[a-z0-9-]{1,63}$/ (lowercase letters, digits, hyphens)");
+  }
+  const asset = getAddress3(args.asset);
+  const creatorAgentId = typeof args.creatorAgentId === "bigint" ? args.creatorAgentId : BigInt(args.creatorAgentId);
+  if (creatorAgentId < 0n)
+    throw usage("`creatorAgentId` must be non-negative");
+  const factory = getDeployment(chainId).sherwood.factory;
+  const data = encodeFunctionData3({
+    abi: SYNDICATE_FACTORY_ABI,
+    functionName: "createSyndicate",
+    args: [
+      creatorAgentId,
+      {
+        metadataURI: args.metadataURI,
+        asset,
+        name: args.name,
+        symbol: args.symbol,
+        openDeposits: args.openDeposits,
+        subdomain: args.subdomain
+      }
+    ]
+  });
+  return {
+    txs: [{ to: factory, data, value: ZERO_VALUE3, chainId }],
+    preconditions: [
+      // Creator must own the ERC-8004 NFT for `creatorAgentId` and have
+      // pre-staked the owner bond via guardianRegistry.prepareOwnerStake.
+      // No on-chain check from the SDK side — agent verifies upstream.
+    ],
+    description: `Create fund "${args.subdomain}" with ${args.openDeposits ? "open" : "whitelisted"} deposits.`,
+    note: "Caller must own the ERC-8004 NFT for `creatorAgentId` and must have called `guardianRegistry.prepareOwnerStake` first to bond the owner stake. The factory's `createSyndicate` deploys a vault proxy + binds the owner stake atomically."
+  };
+}
+
+// ../sdk/dist/encoders/strategy.js
+import { concatHex, encodeAbiParameters, encodeFunctionData as encodeFunctionData4, encodePacked, getAddress as getAddress4, getCreate2Address, isHex, keccak256 } from "viem";
+var ZERO_ADDRESS3 = "0x0000000000000000000000000000000000000000";
+var ZERO_VALUE4 = "0x0";
+var ERC1167_PREFIX = "0x3d602d80600a3d3981f3363d3d373d3d3d363d73";
+var ERC1167_SUFFIX = "0x5af43d82803e903d91602b57fd5bf3";
+function predictStrategyCloneAddress(factory, template, salt) {
+  const initCode = concatHex([
+    ERC1167_PREFIX,
+    getAddress4(template),
+    ERC1167_SUFFIX
+  ]);
+  return getCreate2Address({
+    from: getAddress4(factory),
+    salt,
+    bytecode: initCode
+  });
+}
+function deriveStrategySalt(vault, proposer, template, initData) {
+  return keccak256(encodePacked(["address", "address", "address", "bytes"], [getAddress4(vault), getAddress4(proposer), getAddress4(template), initData]));
+}
+function effectiveStrategySalt(vault, salt) {
+  return keccak256(encodeAbiParameters([{ type: "address" }, { type: "bytes32" }], [getAddress4(vault), salt]));
+}
+function requireSalt(value) {
+  if (typeof value !== "string" || !isHex(value) || value.length !== 66) {
+    throw usage("`salt` must be a 0x-prefixed 32-byte hex string (66 chars)");
+  }
+  return value;
+}
+function encodeStrategyDeploy(args, chainId) {
+  const template = getAddress4(args.template);
+  const vault = getAddress4(args.vault);
+  const proposer = getAddress4(args.proposer);
+  if (typeof args.initData !== "string" || !isHex(args.initData)) {
+    throw usage("`initData` must be a 0x-prefixed hex string");
+  }
+  if (template === ZERO_ADDRESS3) {
+    throw usage("`template` must be a non-zero address");
+  }
+  if (proposer === ZERO_ADDRESS3) {
+    throw usage("`proposer` must be a non-zero address");
+  }
+  const factory = args.factory ? getAddress4(args.factory) : getDeployment(chainId).sherwood.strategyFactory;
+  if (factory === ZERO_ADDRESS3) {
+    throw unavailable(`StrategyFactory is not yet deployed on chain ${chainId} \u2014 mirror its address into the SDK once it lands (issue #387), or pass an explicit \`factory\`.`);
+  }
+  const salt = args.salt ? requireSalt(args.salt) : deriveStrategySalt(vault, proposer, template, args.initData);
+  const clone = predictStrategyCloneAddress(factory, template, effectiveStrategySalt(vault, salt));
+  const data = encodeFunctionData4({
+    abi: STRATEGY_FACTORY_ABI,
+    functionName: "cloneAndInitDeterministic",
+    args: [template, vault, proposer, args.initData, salt]
+  });
+  const tx = { to: factory, data, value: ZERO_VALUE4, chainId };
+  return {
+    txs: [tx],
+    preconditions: [],
+    clone,
+    salt,
+    factory,
+    description: `Deploy a strategy clone of ${template} for vault ${vault} (deterministic \u2014 clone at ${clone}).`,
+    note: "Broadcast this tx from `proposer` \u2014 the factory requires proposer == msg.sender, and msg.sender must be the vault owner or a registered agent. The vault must be registered on the SyndicateFactory and `template` must be on the factory's allowlist (the factory reverts otherwise). The clone address is fixed by (factory, template, vault, salt) \u2014 reference it as the proposal `strategy` and inside executeCalls/settlementCalls. The factory binds the salt to the vault, and `_authClone` lets only the vault's owner/agents deploy there, so the predicted address can't be front-run."
+  };
+}
+
+// ../sdk/dist/encoders/identity.js
+import { encodeFunctionData as encodeFunctionData5, getAddress as getAddress5 } from "viem";
+var ZERO_ADDRESS4 = "0x0000000000000000000000000000000000000000";
+var ERC8004_TYPE = "https://eips.ethereum.org/EIPS/eip-8004#registration-v1";
+var B64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function toBase64Utf8(str) {
+  const bin = encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, (_, h) => String.fromCharCode(parseInt(h, 16)));
+  let out = "";
+  for (let i = 0; i < bin.length; i += 3) {
+    const a = bin.charCodeAt(i);
+    const hasB = i + 1 < bin.length;
+    const hasC = i + 2 < bin.length;
+    const b = hasB ? bin.charCodeAt(i + 1) : 0;
+    const c = hasC ? bin.charCodeAt(i + 2) : 0;
+    out += B64_ALPHABET[a >> 2];
+    out += B64_ALPHABET[(a & 3) << 4 | b >> 4];
+    out += hasB ? B64_ALPHABET[(b & 15) << 2 | c >> 6] : "=";
+    out += hasC ? B64_ALPHABET[c & 63] : "=";
+  }
+  return out;
+}
+function encodeIdentityMint(args, chainId) {
+  const registry = getDeployment(chainId).identityRegistry;
+  if (registry === ZERO_ADDRESS4) {
+    throw unsupported(`ERC-8004 identity registry is not deployed on chain ${chainId} \u2014 mint on Base (8453).`);
+  }
+  if (!args.name)
+    throw usage("`name` is required");
+  if (!args.description)
+    throw usage("`description` is required");
+  const reg = {
+    type: ERC8004_TYPE,
+    name: args.name,
+    description: args.description
+  };
+  if (args.image)
+    reg.image = args.image;
+  reg.services = [];
+  reg.active = args.active ?? true;
+  reg.x402Support = args.x402Support ?? false;
+  const json = JSON.stringify(reg);
+  const dataUri = `data:application/json;base64,${toBase64Utf8(json)}`;
+  return {
+    txs: [
+      {
+        to: getAddress5(registry),
+        data: encodeFunctionData5({
+          abi: IDENTITY_REGISTRY_ABI,
+          functionName: "register",
+          args: [dataUri, []]
+        }),
+        value: "0x0",
+        chainId
+      }
+    ],
+    preconditions: [],
+    description: `Mint an ERC-8004 agent identity "${args.name}" on chain ${chainId}.`,
+    note: "ERC-8004 identity is minted on Base. Read the resulting token id from the mint receipt (chainId:tokenId); reference it when creating or joining funds."
+  };
+}
+
+// ../sdk/dist/encoders/eas.js
+import { encodeAbiParameters as encodeAbiParameters2, encodeFunctionData as encodeFunctionData6, getAddress as getAddress6, parseAbiParameters } from "viem";
+var ZERO_ADDRESS5 = "0x0000000000000000000000000000000000000000";
+var ZERO_BYTES322 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var JOIN_REQUEST_PARAMS = parseAbiParameters("uint256, uint256, address, string");
+var AGENT_APPROVED_PARAMS = parseAbiParameters("uint256, uint256, address");
+var toBig = (x) => typeof x === "bigint" ? x : BigInt(x);
+function formatMessageWithRef(message, referrerAgentId) {
+  if (referrerAgentId == null)
+    return message;
+  return `[ref:${referrerAgentId}] ${message}`;
+}
+function formatMessageWithChain(message, sourceSlug, easSlug) {
+  if (sourceSlug === easSlug)
+    return message;
+  return `[chain:${sourceSlug}] ${message}`;
+}
+function buildAttestTx(easAddress, schema, recipient, data, chainId) {
+  return {
+    to: getAddress6(easAddress),
+    data: encodeFunctionData6({
+      abi: EAS_ABI,
+      functionName: "attest",
+      args: [
+        {
+          schema,
+          data: {
+            recipient,
+            expirationTime: 0n,
+            revocable: true,
+            refUID: ZERO_BYTES322,
+            data,
+            value: 0n
+          }
+        }
+      ]
+    }),
+    value: "0x0",
+    chainId
+  };
+}
+function encodeJoinRequest(args, chainId) {
+  const dep = getDeployment(chainId);
+  const eas = dep.eas;
+  if (eas.address === ZERO_ADDRESS5) {
+    throw unsupported(`No EAS coordination path on chain ${chainId} \u2014 join requests require a deployment whose attestations are pinned to a coordination chain.`);
+  }
+  const easSlug = getDeployment(eas.chainId).slug;
+  const message = formatMessageWithChain(formatMessageWithRef(args.message, args.referrerAgentId), dep.slug, easSlug);
+  const data = encodeAbiParameters2(JOIN_REQUEST_PARAMS, [
+    toBig(args.fundId),
+    toBig(args.agentId),
+    getAddress6(args.vault),
+    message
+  ]);
+  return {
+    txs: [
+      buildAttestTx(eas.address, eas.schemas.joinRequest, getAddress6(args.creator), data, eas.chainId)
+    ],
+    preconditions: [],
+    description: `Request to join fund ${toBig(args.fundId).toString()} (vault ${getAddress6(args.vault)}).`,
+    note: "EAS coordination attestation \u2014 submitted on the coordination chain (see txs[0].chainId), not necessarily the fund's chain. Revocable; the creator discovers it via the join-request schema."
+  };
+}
+function encodeApproveAgent(args, chainId) {
+  const dep = getDeployment(chainId);
+  const eas = dep.eas;
+  if (eas.address === ZERO_ADDRESS5) {
+    throw unsupported(`No EAS coordination path on chain ${chainId} \u2014 approvals require a deployment whose attestations are pinned to a coordination chain.`);
+  }
+  const registerTx = encodeRegisterAgent({
+    vault: args.vault,
+    agentAddress: args.agentAddress,
+    agentId: toBig(args.agentId)
+  }, chainId).txs[0];
+  const data = encodeAbiParameters2(AGENT_APPROVED_PARAMS, [
+    toBig(args.fundId),
+    toBig(args.agentId),
+    getAddress6(args.vault)
+  ]);
+  const attestTx = buildAttestTx(eas.address, eas.schemas.agentApproved, getAddress6(args.agentAddress), data, eas.chainId);
+  return {
+    txs: [registerTx, attestTx],
+    preconditions: [],
+    description: `Approve agent ${toBig(args.agentId).toString()} for fund ${toBig(args.fundId).toString()}: register on the vault (chain ${chainId}) + AGENT_APPROVED attestation on the coordination chain.`,
+    note: "Vault owner only. Two txs, potentially on two chains: registerAgent runs on the fund's chain; the approval attestation runs on the coordination chain (see txs[1].chainId)."
+  };
+}
+
+// ../sdk/dist/encoders/guardian.js
+import { encodeFunctionData as encodeFunctionData7, getAddress as getAddress7 } from "viem";
+var ZERO_VALUE5 = "0x0";
+function swoodTx(chainId, data) {
+  const swood = getDeployment(chainId).sherwood.stakedWood;
+  if (swood === "0x0000000000000000000000000000000000000000") {
+    throw unsupported(`sWOOD (StakedWood) is not deployed on chain ${chainId} yet`);
+  }
+  return { to: swood, data, value: ZERO_VALUE5, chainId };
+}
+function registryTx(chainId, data) {
+  const registry = getDeployment(chainId).sherwood.guardianRegistry;
+  if (registry === "0x0000000000000000000000000000000000000000") {
+    throw unsupported(`Guardian registry is not deployed on chain ${chainId} yet`);
+  }
+  return { to: registry, data, value: ZERO_VALUE5, chainId };
+}
+function parseUint(value, field) {
+  if (typeof value === "bigint") {
+    if (value < 0n)
+      throw usage(`\`${field}\` must be a non-negative integer`);
+    return value;
+  }
+  if (typeof value === "number") {
+    if (!Number.isInteger(value) || value < 0) {
+      throw usage(`\`${field}\` must be a non-negative integer`);
+    }
+    return BigInt(value);
+  }
+  if (!/^\d+$/.test(value)) {
+    throw usage(`\`${field}\` must be a non-negative integer string, got "${value}"`);
+  }
+  return BigInt(value);
+}
+function encodeGuardianStake(args, chainId) {
+  if (args.amount <= 0n)
+    throw usage("`amount` must be > 0");
+  const agentId = parseUint(args.agentId, "agentId");
+  const data = encodeFunctionData7({
+    abi: STAKED_WOOD_ABI,
+    functionName: "stakeAsGuardian",
+    args: [args.amount, agentId]
+  });
+  const deployment = getDeployment(chainId);
+  const wood = deployment.tokens.wood?.address;
+  const swood = deployment.sherwood.stakedWood;
+  if (!wood || wood === "0x0000000000000000000000000000000000000000" || swood === "0x0000000000000000000000000000000000000000") {
+    throw unsupported(`WOOD / sWOOD is not deployed on chain ${chainId} yet`);
+  }
+  return {
+    txs: [swoodTx(chainId, data)],
+    preconditions: [
+      // Caller must have approved WOOD for sWOOD (StakedWood); agent should
+      // check this client-side and prepend an ERC20.approve if needed.
+      {
+        type: "allowance",
+        token: wood,
+        spender: swood,
+        min: args.amount.toString(),
+        minDecimal: args.amount.toString()
+      }
+    ],
+    description: `Stake ${args.amount.toString()} WOOD as guardian (agent ${agentId.toString()}).`,
+    note: "Caller must have approved WOOD for sWOOD (StakedWood) first. Stake locks the WOOD; use /prepare/guardian-unstake later to start the 7d unstake cooldown."
+  };
+}
+var GUARDIAN_UNSTAKE_FN = {
+  request: "requestUnstakeGuardian",
+  cancel: "cancelUnstakeGuardian",
+  claim: "claimUnstakeGuardian"
+};
+function encodeGuardianUnstake(args, chainId) {
+  const fn = GUARDIAN_UNSTAKE_FN[args.action];
+  if (!fn) {
+    throw usage(`\`action\` must be one of: ${Object.keys(GUARDIAN_UNSTAKE_FN).join(", ")}`);
+  }
+  const data = encodeFunctionData7({
+    abi: GUARDIAN_REGISTRY_ABI,
+    functionName: fn,
+    args: []
+  });
+  return {
+    txs: [registryTx(chainId, data)],
+    preconditions: [],
+    description: `Guardian unstake ${args.action}.`,
+    note: args.action === "request" ? "Starts a 7-day cooldown. After it elapses, call again with action=claim to withdraw." : args.action === "claim" ? "Withdraws the unstake amount once the 7-day cooldown has elapsed." : "Cancels a pending unstake request and re-activates the guardian."
+  };
+}
+function encodeVoteOnProposal(args, chainId) {
+  let governor;
+  try {
+    governor = getAddress7(args.governor);
+  } catch {
+    throw usage("`governor` must be a 0x-prefixed 40-char hex address");
+  }
+  const support = GUARDIAN_VOTE_TYPES.indexOf(args.vote);
+  if (support <= 0) {
+    throw usage("`vote` must be one of: Approve, Block");
+  }
+  const proposalId = parseUint(args.proposalId, "proposalId");
+  const data = encodeFunctionData7({
+    abi: GUARDIAN_REGISTRY_ABI,
+    functionName: "voteOnProposal",
+    args: [governor, proposalId, support]
+  });
+  const underwriting = args.vote === "Approve" ? " APPROVE books coverage against the CALLER'S OWN slashable guardian bond (ExposureLedger.recordApproval). If this proposal is later challenged or slashed, your WOOD stake is at risk \u2014 not another guardian's. An over-exposed guardian books nothing rather than reverting; the vote still lands." : " Block votes do not book coverage. Slash severity is computed at resolveReview from block-side decisiveness.";
+  return {
+    txs: [registryTx(chainId, data)],
+    preconditions: [],
+    description: `Guardian review vote ${args.vote} on proposal ${proposalId.toString()} (governor ${governor}).`,
+    note: `voteOnProposal(governor, proposalId, vote) \u2014 3 args, selector 0x3ad95b6d, no slashBps.${underwriting}`
+  };
+}
+
+// ../sdk/dist/reads/funds.js
+import { getAddress as getAddress8 } from "viem";
+
+// src/commands/identity.ts
+var IDENTITY_REGISTRY_ABI2 = [
+  {
+    name: "balanceOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "owner", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "ownerOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [{ name: "", type: "address" }]
+  }
+];
+function getAgent0SDK() {
+  const key = requirePrivateKey();
+  const chain = getChain();
+  const sdkConfig = {
+    chainId: chain.id,
+    rpcUrl: getRpcUrl(),
+    privateKey: key
+  };
+  if (chain.id !== getChainConfig().chain.id) {
+    sdkConfig.registryOverrides = {
+      [chain.id]: {
+        IDENTITY: AGENT_REGISTRY().IDENTITY_REGISTRY,
+        REPUTATION: AGENT_REGISTRY().REPUTATION_REGISTRY
+      }
+    };
+  }
+  return new SDK(sdkConfig);
+}
+async function lookupAgentIdByWallet(wallet) {
+  return withNetwork(COORDINATION_NETWORK, async () => {
+    const client = getPublicClient();
+    const registry = AGENT_REGISTRY().IDENTITY_REGISTRY;
+    const balance = await client.readContract({
+      address: registry,
+      abi: [{
+        name: "balanceOf",
+        type: "function",
+        stateMutability: "view",
+        inputs: [{ name: "owner", type: "address" }],
+        outputs: [{ name: "", type: "uint256" }]
+      }],
+      functionName: "balanceOf",
+      args: [wallet]
+    });
+    if (balance === 0n) return null;
+    const logs = await client.getLogs({
+      address: registry,
+      event: {
+        type: "event",
+        name: "Transfer",
+        inputs: [
+          { indexed: true, name: "from", type: "address" },
+          { indexed: true, name: "to", type: "address" },
+          { indexed: true, name: "tokenId", type: "uint256" }
+        ]
+      },
+      args: { from: "0x0000000000000000000000000000000000000000", to: wallet },
+      fromBlock: 0n
+    });
+    const last = logs[logs.length - 1];
+    return last?.args?.tokenId ?? null;
+  });
+}
+function registerIdentityCommands(program) {
+  const identity = program.command("identity").description("Manage ERC-8004 agent identity (via Agent0 SDK)");
+  identity.command("mint").description("Register a new ERC-8004 agent identity (required before creating/joining funds)").requiredOption("--name <name>", "Agent name (e.g. 'Alpha Seeker Agent')").option("--description <desc>", "Agent description", "Sherwood fund agent").option("--image <uri>", "Agent image URI (IPFS recommended)").action(async (opts) => {
+    if (isCalldataOnly()) {
+      emitCalldata(
+        encodeIdentityMint(
+          {
+            name: opts.name,
+            description: opts.description,
+            image: opts.image
+          },
+          4663
+        )
+      );
+      return;
+    }
+    const account = getAccount();
+    const existingId = getAgentId();
+    if (existingId) {
+      console.log(chalk.yellow(`You already have an agent identity saved: #${existingId}`));
+      console.log(chalk.dim("  Minting a new one anyway. The old ID is not affected."));
+      console.log();
+    }
+    const spinner = ora("Minting ERC-8004 identity on Robinhood mainnet...").start();
+    try {
+      const tokenId = await withNetwork(COORDINATION_NETWORK, async () => {
+        const client = getPublicClient();
+        const balance = await client.getBalance({ address: account.address });
+        if (balance === 0n) {
+          throw new Error(
+            `No ETH on Robinhood mainnet (chain 4663) for ${account.address}. Identity is minted on the coordination chain regardless of your fund's chain; a mint costs well under 0.0001 ETH.`
+          );
+        }
+        const action = encodeIdentityMint(
+          { name: opts.name, description: opts.description, image: opts.image },
+          4663
+        );
+        const tx = action.txs[0];
+        const hash = await sendTxWithRetry({
+          account,
+          chain: getChain(),
+          to: tx.to,
+          data: tx.data
+        });
+        spinner.text = "Waiting for confirmation...";
+        const receipt = await waitForReceipt(hash);
+        const TRANSFER = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+        const mint = receipt.logs.find(
+          (l) => l.address.toLowerCase() === tx.to.toLowerCase() && l.topics[0] === TRANSFER
+        );
+        if (!mint?.topics[3]) throw new Error("no Transfer event in mint receipt");
+        return Number(BigInt(mint.topics[3]));
+      });
+      setAgentId(tokenId);
+      spinner.succeed(`Agent identity registered: #${tokenId}`);
+      console.log(chalk.dim(`  Chain:     Robinhood mainnet (4663) \u2014 the coordination chain`));
+      console.log(chalk.dim(`  Name:      ${opts.name}`));
+      console.log(chalk.dim(`  Owner:     ${account.address}`));
+      console.log(chalk.dim(`  Saved to   ~/.sherwood/config.json`));
+      console.log();
+      console.log(chalk.green("You can now create funds:"));
+      console.log(chalk.dim(`  sherwood fund create --agent-id ${tokenId} --subdomain <name> --name <name>`));
+    } catch (err) {
+      spinner.fail("Failed to register identity");
+      console.error(chalk.red(formatContractError(err)));
+      process.exit(1);
+    }
+  });
+  identity.command("load").description("Load an existing ERC-8004 agent identity into your config").requiredOption("--id <tokenId>", "Agent token ID to load").action(async (opts) => {
+    const account = getAccount();
+    const tokenId = Number(opts.id);
+    const spinner = ora(`Verifying ownership of agent #${tokenId}...`).start();
+    try {
+      const owner = await withNetwork(
+        COORDINATION_NETWORK,
+        () => getPublicClient().readContract({
+          address: AGENT_REGISTRY().IDENTITY_REGISTRY,
+          abi: IDENTITY_REGISTRY_ABI2,
+          functionName: "ownerOf",
+          args: [BigInt(tokenId)]
+        })
+      );
+      if (owner.toLowerCase() !== account.address.toLowerCase()) {
+        spinner.fail(`Agent #${tokenId} is owned by ${owner}, not your wallet`);
+        process.exit(1);
+      }
+      setAgentId(tokenId);
+      spinner.succeed(`Agent #${tokenId} loaded and saved to config`);
+      console.log(chalk.dim(`  Owner:  ${account.address}`));
+      console.log(chalk.dim(`  Saved to ~/.sherwood/config.json`));
+    } catch (err) {
+      spinner.fail("Failed to load identity");
+      console.error(chalk.red(formatContractError(err)));
+      process.exit(1);
+    }
+  });
+  identity.command("link-virtuals").description("Link a Virtuals economyOS agent identity (ERC-8004 on Base) to this Sherwood install").option("--wallet <address>", "economyOS agent wallet (default: auto-detect via `acp wallet address`)").option("--agent-id <tokenId>", "ERC-8004 token ID on the issuing chain (default: resolve via Agent0 SDK)").option("--chain-id <id>", "Issuing chain ID (4663 = Robinhood Chain, 8453 = Base, 84532 = Base Sepolia)", String(DEFAULT_ISSUING_CHAIN_ID)).option("--binding-sig <hex>", "EIP-191 signature of the binding message by the economyOS wallet").option("--wallet-only", "Link without an ERC-8004 registration \u2014 the economyOS wallet + binding signature are the identity (agentId 0)").action(async (opts) => {
+    const account = getAccount();
+    const issuingChainId = opts.walletOnly ? WALLET_ONLY_CHAIN_ID : parseInt(opts.chainId, 10);
+    if (!opts.walletOnly && !ISSUING_CHAINS[issuingChainId]) {
+      console.error(chalk.red(`Unsupported issuing chain ${opts.chainId}. Supported: ${Object.keys(ISSUING_CHAINS).join(", ")}`));
+      process.exit(1);
+    }
+    const spinner = ora("Resolving economyOS agent...").start();
+    try {
+      let virtualsWallet = opts.wallet;
+      let virtualsAgentId;
+      if (await detectAcp()) {
+        const who = await acpWhoami();
+        virtualsAgentId = who?.agentId;
+        if (!virtualsWallet) {
+          virtualsWallet = await acpWalletAddress() ?? void 0;
+        }
+      }
+      if (!virtualsWallet) {
+        spinner.fail("Could not resolve the economyOS agent wallet");
+        console.error(chalk.dim("  Install + authenticate the acp CLI (npm i -g @virtuals-protocol/acp-cli; acp configure)"));
+        console.error(chalk.dim("  or pass --wallet <address> explicitly."));
+        process.exit(1);
+      }
+      let tokenId;
+      if (opts.walletOnly) {
+        tokenId = 0n;
+      } else if (opts.agentId) {
+        tokenId = BigInt(opts.agentId);
+      } else {
+        spinner.text = `Searching ERC-8004 registry on chain ${issuingChainId} for ${virtualsWallet}...`;
+        const sdk = new SDK({
+          chainId: issuingChainId,
+          rpcUrl: ISSUING_CHAINS[issuingChainId].chain.rpcUrls.default.http[0],
+          privateKey: generatePrivateKey()
+        });
+        const results = await sdk.searchAgents({
+          walletAddress: virtualsWallet,
+          chains: [issuingChainId]
+        });
+        if (results.length === 0) {
+          spinner.fail(`No ERC-8004 registration found for ${virtualsWallet} on chain ${issuingChainId}`);
+          console.error(chalk.dim("  Register first via the Virtuals CLI:"));
+          console.error(chalk.dim(`    acp agent register-erc8004 --agent-id ${virtualsAgentId ?? "<id>"} --chain-id ${issuingChainId}`));
+          console.error(chalk.dim("  Then re-run this command (or pass --agent-id <tokenId> directly)."));
+          console.error(chalk.dim("  No registration possible yet? Link without one: --wallet-only"));
+          process.exit(1);
+        }
+        if (results.length > 1) {
+          spinner.fail(`Wallet ${virtualsWallet} has ${results.length} ERC-8004 registrations on chain ${issuingChainId} \u2014 pick one explicitly`);
+          for (const a of results) {
+            const idStr2 = String(a.agentId);
+            const tid = idStr2.includes(":") ? idStr2.split(":")[1] : idStr2;
+            console.error(chalk.dim(`    #${tid}  ${a.name || "(no name)"}`));
+          }
+          console.error(chalk.green("  Re-run with: sherwood identity link-virtuals --agent-id <tokenId>"));
+          process.exit(1);
+        }
+        const idStr = String(results[0].agentId);
+        tokenId = BigInt(idStr.includes(":") ? idStr.split(":")[1] : idStr);
+      }
+      if (tokenId > BigInt(Number.MAX_SAFE_INTEGER)) {
+        spinner.fail(`Token ID ${tokenId} exceeds Number.MAX_SAFE_INTEGER \u2014 cannot be stored in config`);
+        process.exit(1);
+      }
+      if (!opts.walletOnly) {
+        spinner.text = `Verifying ownerOf(#${tokenId}) on chain ${issuingChainId}...`;
+        const owner = await ownerOfOnIssuingChain(issuingChainId, tokenId);
+        if (owner.toLowerCase() !== virtualsWallet.toLowerCase()) {
+          spinner.fail(`Agent #${tokenId} on chain ${issuingChainId} is owned by ${owner}, not ${virtualsWallet}`);
+          process.exit(1);
+        }
+      }
+      const self = virtualsWallet.toLowerCase() === account.address.toLowerCase();
+      const bindingMessage = buildBindingMessage(account.address, issuingChainId, tokenId);
+      let binding;
+      if (!self) {
+        let bindingSig = opts.bindingSig;
+        if (!bindingSig) {
+          spinner.text = "Requesting binding signature from the economyOS wallet (acp wallet sign-message)...";
+          bindingSig = await acpSignMessage(bindingMessage) ?? void 0;
+          if (bindingSig) {
+            console.log(chalk.dim("  Binding signed automatically via acp."));
+          }
+        }
+        if (!bindingSig) {
+          spinner.fail("Binding signature required (economyOS wallet differs from your Sherwood wallet)");
+          console.error();
+          console.error(chalk.bold("  Sign this exact message with the economyOS agent wallet:"));
+          console.error(chalk.green(`    ${bindingMessage}`));
+          console.error();
+          console.error(chalk.dim(`  acp wallet sign-message --message "${bindingMessage}" --json`));
+          console.error(chalk.dim("  Then re-run with --binding-sig <signature>."));
+          process.exit(1);
+        }
+        spinner.text = "Verifying binding signature...";
+        const ok = await verifyBinding({
+          sherwoodEoa: account.address,
+          issuingChainId,
+          tokenId,
+          virtualsWallet,
+          signature: bindingSig
+        });
+        if (!ok) {
+          spinner.fail("Binding signature does not recover to the economyOS wallet");
+          console.error(chalk.dim(`  Expected signer: ${virtualsWallet}`));
+          console.error(chalk.dim(`  Signed message must be exactly: ${bindingMessage}`));
+          process.exit(1);
+        }
+        binding = { sig: bindingSig, message: bindingMessage };
+      }
+      setVirtualsIdentity(Number(tokenId), issuingChainId, {
+        agentId: virtualsAgentId,
+        wallet: virtualsWallet,
+        binding
+      });
+      spinner.succeed(
+        opts.walletOnly ? "Virtuals identity linked: wallet-only (no ERC-8004 \u2014 upgrade later by re-linking after registration)" : `Virtuals identity linked: agent #${tokenId} (chain ${issuingChainId})`
+      );
+      console.log(chalk.dim(`  economyOS wallet: ${virtualsWallet}`));
+      if (virtualsAgentId) console.log(chalk.dim(`  Virtuals agent:   ${virtualsAgentId}`));
+      console.log(chalk.dim(`  Sherwood wallet:  ${account.address}${self ? " (same as economyOS wallet \u2014 no binding needed)" : " (bound via signature)"}`));
+      console.log(chalk.dim(`  Saved to          ~/.sherwood/config.json`));
+      console.log();
+      console.log(chalk.green("You can now create or join funds with this identity:"));
+      console.log(chalk.dim(`  sherwood fund create --agent-id ${tokenId} --subdomain <name> --name <name>`));
+    } catch (err) {
+      spinner.fail("Failed to link Virtuals identity");
+      console.error(chalk.red(formatContractError(err)));
+      process.exit(1);
+    }
+  });
+  identity.command("find").description("Search ERC-8004 agents by wallet address or name (recover a lost agent ID)").option("--wallet <address>", "Filter by owner / wallet address").option("--name <text>", "Filter by agent name (exact or substring match, depending on registry)").option("--all-chains", "Search across all chains, not just the active one").action(async (opts) => {
+    if (!opts.wallet && !opts.name) {
+      console.error(chalk.red("Pass --wallet <address> or --name <text> (or both)."));
+      process.exit(1);
+    }
+    const spinner = ora("Searching ERC-8004 registry...").start();
+    try {
+      const sdk = getAgent0SDK();
+      const filters = {};
+      if (opts.wallet) filters.walletAddress = opts.wallet;
+      if (opts.name) filters.name = opts.name;
+      filters.chains = opts.allChains ? "all" : [getChain().id];
+      const results = await sdk.searchAgents(filters);
+      spinner.stop();
+      if (results.length === 0) {
+        console.log(chalk.dim("No agents found matching those filters."));
+        console.log(chalk.dim("If you minted on a different chain, retry with --all-chains."));
+        return;
+      }
+      console.log();
+      console.log(chalk.bold(`Found ${results.length} agent${results.length === 1 ? "" : "s"}`));
+      console.log(chalk.dim("\u2500".repeat(50)));
+      for (const a of results) {
+        const idStr = String(a.agentId);
+        const tokenId = idStr.includes(":") ? idStr.split(":")[1] : idStr;
+        console.log(`  ${chalk.bold(`#${tokenId}`)}  ${a.name || chalk.dim("(no name)")}`);
+        console.log(chalk.dim(`    Chain:  ${a.chainId}`));
+        console.log(chalk.dim(`    Full:   ${idStr}`));
+        if (a.owners?.length) {
+          console.log(chalk.dim(`    Owner:  ${a.owners[0]}`));
+        }
+        if (a.walletAddress) {
+          console.log(chalk.dim(`    Wallet: ${a.walletAddress}`));
+        }
+      }
+      console.log();
+      console.log(chalk.green("To bind one of these to this machine:"));
+      console.log(chalk.dim(`  sherwood identity load --id <tokenId>`));
+    } catch (err) {
+      spinner.fail("Search failed");
+      console.error(chalk.red(formatContractError(err)));
+      process.exit(1);
+    }
+  });
+  identity.command("status").description("Show your agent identity status").action(async () => {
+    const account = getAccount();
+    if (getIdentityProvider() === "virtuals") {
+      const virtuals = getVirtualsIdentity();
+      const savedId = getAgentId();
+      const issuingChainId = getIdentityChainId();
+      console.log();
+      console.log(chalk.bold("Agent Identity (ERC-8004 via Virtuals economyOS)"));
+      console.log(chalk.dim("\u2500".repeat(40)));
+      console.log(`  Sherwood wallet:  ${account.address}`);
+      console.log(`  economyOS wallet: ${virtuals?.wallet ?? chalk.red("(missing)")}`);
+      if (virtuals?.agentId) console.log(`  Virtuals agent:   ${virtuals.agentId}`);
+      const walletOnly = issuingChainId === WALLET_ONLY_CHAIN_ID;
+      console.log(`  Issuing chain:    ${walletOnly ? chalk.yellow("wallet-only (no ERC-8004)") : issuingChainId ?? chalk.red("(missing)")}`);
+      console.log(`  Saved ID:         ${savedId != null ? walletOnly ? chalk.dim("0 (wallet-only)") : `#${savedId}` : chalk.red("(missing)")}`);
+      if (virtuals?.wallet && savedId != null && issuingChainId != null) {
+        const spinner2 = ora("Re-verifying link...").start();
+        try {
+          let ownerOk = true;
+          let owner;
+          if (!walletOnly) {
+            owner = await ownerOfOnIssuingChain(issuingChainId, BigInt(savedId));
+            ownerOk = owner.toLowerCase() === virtuals.wallet.toLowerCase();
+          }
+          let bindingOk = virtuals.wallet.toLowerCase() === account.address.toLowerCase();
+          if (!bindingOk && virtuals.binding?.sig) {
+            bindingOk = await verifyBinding({
+              sherwoodEoa: account.address,
+              issuingChainId,
+              tokenId: BigInt(savedId),
+              virtualsWallet: virtuals.wallet,
+              signature: virtuals.binding.sig
+            });
+          }
+          spinner2.stop();
+          if (walletOnly) {
+            console.log(`  NFT ownership:    ${chalk.dim("n/a (wallet-only link)")}`);
+          } else {
+            console.log(`  NFT ownership:    ${ownerOk ? chalk.green("verified") : chalk.red(`FAILED (owner is ${owner})`)}`);
+          }
+          console.log(`  Binding:          ${bindingOk ? chalk.green("verified") : chalk.red("FAILED")}`);
+          if (!ownerOk) {
+            console.log(chalk.yellow("  The NFT moved since linking \u2014 re-run 'sherwood identity link-virtuals'."));
+          }
+          if (walletOnly) {
+            console.log(chalk.dim("  Upgrade to a registered link once ERC-8004 registration is available:"));
+            console.log(chalk.dim("    acp agent register-erc8004 ... && sherwood identity link-virtuals"));
+          }
+        } catch (err) {
+          spinner2.warn("Could not re-verify against the issuing chain");
+          console.log(chalk.dim(`  ${err.message}`));
+        }
+      }
+      console.log();
+      return;
+    }
+    const registry = AGENT_REGISTRY().IDENTITY_REGISTRY;
+    const client = getPublicClient();
+    const spinner = ora("Checking identity...").start();
+    try {
+      const balance = await client.readContract({
+        address: registry,
+        abi: IDENTITY_REGISTRY_ABI2,
+        functionName: "balanceOf",
+        args: [account.address]
+      });
+      spinner.stop();
+      const savedId = getAgentId();
+      console.log();
+      console.log(chalk.bold("Agent Identity (ERC-8004)"));
+      console.log(chalk.dim("\u2500".repeat(40)));
+      console.log(`  Wallet:     ${account.address}`);
+      console.log(`  Registry:   ${registry}`);
+      console.log(`  NFTs owned: ${balance.toString()}`);
+      if (savedId) {
+        try {
+          const owner = await client.readContract({
+            address: registry,
+            abi: IDENTITY_REGISTRY_ABI2,
+            functionName: "ownerOf",
+            args: [BigInt(savedId)]
+          });
+          const isOwner = owner.toLowerCase() === account.address.toLowerCase();
+          console.log(`  Saved ID:   #${savedId} ${isOwner ? chalk.green("(verified)") : chalk.red("(owned by " + owner + ")")}`);
+          if (isOwner) {
+            try {
+              const sdk = getAgent0SDK();
+              const agent = await sdk.loadAgent(`${getChain().id}:${savedId}`);
+              if (agent.name) console.log(`  Name:       ${agent.name}`);
+              if (agent.description) console.log(`  Desc:       ${chalk.dim(agent.description)}`);
+              if (agent.walletAddress) console.log(`  Wallet:     ${agent.walletAddress}`);
+            } catch {
+            }
+          }
+        } catch {
+          console.log(`  Saved ID:   #${savedId} ${chalk.red("(token not found)")}`);
+        }
+        console.log();
+      } else if (balance > 0n) {
+        console.log(`  Saved ID:   ${chalk.yellow("none (but this wallet owns NFTs \u2014 listing below)")}`);
+        console.log();
+        const lookupSpinner = ora("Resolving owned token IDs via Agent0 SDK...").start();
+        try {
+          const sdk = getAgent0SDK();
+          const results = await sdk.searchAgents({
+            walletAddress: account.address,
+            chains: [getChain().id]
+          });
+          lookupSpinner.stop();
+          if (results.length === 0) {
+            console.log(chalk.dim("  No agents resolved for this wallet on the active chain."));
+            console.log(chalk.dim("  If you minted on a different chain, try:"));
+            console.log(chalk.dim("    sherwood identity find --wallet " + account.address + " --all-chains"));
+          } else {
+            console.log(chalk.bold(`  Owned identities on this chain (${results.length}):`));
+            for (const a of results) {
+              const idStr = String(a.agentId);
+              const tokenId = idStr.includes(":") ? idStr.split(":")[1] : idStr;
+              console.log(`    ${chalk.bold(`#${tokenId}`)}  ${a.name || chalk.dim("(no name)")}`);
+            }
+            console.log();
+            console.log(chalk.green("  Bind one to this machine:"));
+            if (results.length === 1) {
+              const idStr = String(results[0].agentId);
+              const tokenId = idStr.includes(":") ? idStr.split(":")[1] : idStr;
+              console.log(chalk.dim(`    sherwood identity load --id ${tokenId}`));
+            } else {
+              console.log(chalk.dim("    sherwood identity load --id <tokenId>"));
+            }
+          }
+        } catch (err) {
+          lookupSpinner.warn("Could not resolve owned token IDs via Agent0 SDK");
+          console.log(chalk.dim(`  ${err.message}`));
+          console.log(chalk.dim("  Try: sherwood identity find --wallet " + account.address));
+        }
+        console.log();
+      } else {
+        console.log(`  Saved ID:   ${chalk.dim("none \u2014 run 'sherwood identity mint --name <name>'")}`);
+        console.log();
+      }
+    } catch (err) {
+      spinner.fail("Failed to check identity");
+      console.error(chalk.red(formatContractError(err)));
+      process.exit(1);
+    }
+  });
+}
+
+export {
+  setCalldataOnly,
+  isCalldataOnly,
+  emitCalldata,
+  encodeDeposit,
+  encodeRedeem,
+  encodeApproveDepositor,
+  encodeRegisterAgent,
+  encodeVote,
+  encodeExecute,
+  encodeSettle,
+  encodeCancel,
+  encodePropose,
+  encodeProposeWithSandbox,
+  encodeUnstick,
+  encodeEmergencySettle,
+  encodeGovernorParam,
+  encodeProtocolFeeBps,
+  encodeCreateFund,
+  encodeStrategyDeploy,
+  encodeJoinRequest,
+  encodeApproveAgent,
+  encodeGuardianStake,
+  encodeGuardianUnstake,
+  encodeVoteOnProposal,
+  DEFAULT_ISSUING_CHAIN_ID,
+  appendVidTag,
+  parseVidTag,
+  stripVidTag,
+  verifyVidTag,
+  makeOwnerOfCache,
+  lookupAgentIdByWallet,
+  registerIdentityCommands
+};
+//# sourceMappingURL=chunk-ILHOW6IA.js.map