@sherwoodagent/cli 0.2.0

package/dist/chunk-CR3ZNOB7.js

@@ -0,0 +1,1451 @@
+// src/lib/network.ts
+import { base, baseSepolia } from "viem/chains";
+var _network = "base";
+function setNetwork(n) {
+  _network = n;
+}
+function getNetwork() {
+  return _network;
+}
+function getChain() {
+  return _network === "base" ? base : baseSepolia;
+}
+function getRpcUrl() {
+  if (_network === "base-sepolia") {
+    return process.env.BASE_SEPOLIA_RPC_URL || "https://sepolia.base.org";
+  }
+  return process.env.BASE_RPC_URL || "https://mainnet.base.org";
+}
+function getExplorerUrl(txHash) {
+  const host = _network === "base" ? "basescan.org" : "sepolia.basescan.org";
+  return `https://${host}/tx/${txHash}`;
+}
+
+// src/lib/addresses.ts
+var BASE_TOKENS = {
+  USDC: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  WETH: "0x4200000000000000000000000000000000000006",
+  cbETH: "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22",
+  wstETH: "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452",
+  cbBTC: "0xcbB7C0000aB88B473b1f5aFd9ef808440eed33Bf",
+  DAI: "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb",
+  AERO: "0x940181a94A35A4569E4529A3CDfB74e38FD98631"
+};
+var BASE_MOONWELL = {
+  COMPTROLLER: "0xfBb21d0380beE3312B33c4353c8936a0F13EF26C",
+  mUSDC: "0xEdc817A28E8B93B03976FBd4a3dDBc9f7D176c22",
+  mWETH: "0x628ff693426583D9a7FB391E54366292F509D457",
+  mCbETH: "0x3bf93770f2d4a794c3d9EBEfBAeBAE2a8f09A5E5",
+  mWstETH: "0x627Fe393Bc6EdDA28e99AE648fD6fF362514304b",
+  mCbBTC: "0xF877ACaFA28c19b96727966690b2f44d35aD5976",
+  mDAI: "0x73b06D8d18De422E269645eaCe15400DE7462417",
+  mAERO: "0x73902f619CEB9B31FD8EFecf435CbDf89E369Ba6"
+};
+var BASE_UNISWAP = {
+  SWAP_ROUTER: "0x2626664c2603336E57B271c5C0b26F421741e481",
+  QUOTER_V2: "0x3d4e44Eb1374240CE5F1B871ab261CD16335B76a"
+};
+var BASE_SEPOLIA_TOKENS = {
+  USDC: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+  // Circle test USDC
+  WETH: "0x4200000000000000000000000000000000000006",
+  // Canonical bridged WETH
+  cbETH: "0x0000000000000000000000000000000000000000",
+  wstETH: "0x0000000000000000000000000000000000000000",
+  cbBTC: "0x0000000000000000000000000000000000000000",
+  DAI: "0x0000000000000000000000000000000000000000",
+  AERO: "0x0000000000000000000000000000000000000000"
+};
+var BASE_SEPOLIA_MOONWELL = {
+  COMPTROLLER: "0x0000000000000000000000000000000000000000",
+  mUSDC: "0x0000000000000000000000000000000000000000",
+  mWETH: "0x0000000000000000000000000000000000000000",
+  mCbETH: "0x0000000000000000000000000000000000000000",
+  mWstETH: "0x0000000000000000000000000000000000000000",
+  mCbBTC: "0x0000000000000000000000000000000000000000",
+  mDAI: "0x0000000000000000000000000000000000000000",
+  mAERO: "0x0000000000000000000000000000000000000000"
+};
+var BASE_SEPOLIA_UNISWAP = {
+  SWAP_ROUTER: "0x94cC0AaC535CCDB3C01d6787D6413C739ae12bc4",
+  // Uniswap V3 SwapRouter02
+  QUOTER_V2: "0xC5290058841028F1614F3A6F0F5816cAd0df5E27"
+  // Uniswap V3 QuoterV2
+};
+var BASE_ENS = {
+  L2_REGISTRAR: "0x0000000000000000000000000000000000000000",
+  // TODO: set after mainnet deploy
+  L2_REGISTRY: "0x0000000000000000000000000000000000000000"
+  // TODO: set after mainnet deploy
+};
+var BASE_SEPOLIA_ENS = {
+  L2_REGISTRAR: "0x1fCbe9dFC25e3fa3F7C55b26c7992684A4758b47",
+  L2_REGISTRY: "0x06eb7b85b59bc3e50fe4837be776cdd26de602cf"
+};
+var BASE_AGENT_REGISTRY = {
+  IDENTITY_REGISTRY: "0x8004A169FB4a3325136EB29fA0ceB6D2e539a432",
+  REPUTATION_REGISTRY: "0x8004BAa17C55a88189AE136b182e5fdA19dE9b63"
+};
+var BASE_SEPOLIA_AGENT_REGISTRY = {
+  IDENTITY_REGISTRY: "0x8004A818BFB912233c491871b3d84c89A494BD9e",
+  REPUTATION_REGISTRY: "0x8004B663056A597Dffe9eCcC1965A193B7388713"
+};
+var BASE_SHERWOOD = {
+  FACTORY: "0x0000000000000000000000000000000000000000",
+  // TODO: set after mainnet deploy
+  STRATEGY_REGISTRY: "0x0000000000000000000000000000000000000000"
+  // TODO: set after mainnet deploy
+};
+var BASE_SEPOLIA_SHERWOOD = {
+  FACTORY: "0xc705F04fF2781aF9bB53ba416Cb32A29540c4624",
+  STRATEGY_REGISTRY: "0x8A45f769553D10F26a6633d019B04f7805b1368A"
+};
+var BASE_VENICE = {
+  VVV: "0xacfe6019ed1a7dc6f7b508c02d1b04ec88cc21bf",
+  STAKING: "0x321b7ff75154472b18edb199033ff4d116f340ff",
+  // also the sVVV ERC-20
+  DIEM: "0xF4d97F2da56e8c3098f3a8D538DB630A2606a024"
+};
+var BASE_SEPOLIA_VENICE = {
+  VVV: "0x0000000000000000000000000000000000000000",
+  STAKING: "0x0000000000000000000000000000000000000000",
+  DIEM: "0x0000000000000000000000000000000000000000"
+};
+var BASE_EAS = {
+  EAS: "0x4200000000000000000000000000000000000021",
+  SCHEMA_REGISTRY: "0x4200000000000000000000000000000000000020"
+};
+var BASE_SEPOLIA_EAS = {
+  EAS: "0x4200000000000000000000000000000000000021",
+  SCHEMA_REGISTRY: "0x4200000000000000000000000000000000000020"
+};
+var BASE_EAS_SCHEMAS = {
+  SYNDICATE_JOIN_REQUEST: "0x0000000000000000000000000000000000000000000000000000000000000000",
+  AGENT_APPROVED: "0x0000000000000000000000000000000000000000000000000000000000000000"
+};
+var BASE_SEPOLIA_EAS_SCHEMAS = {
+  SYNDICATE_JOIN_REQUEST: "0x1e7ce17b16233977ba913b156033e98f52029f4bee273a4abefe6c15ce11d5ef",
+  AGENT_APPROVED: "0x1013f7b38f433b2a93fc5ac162482813081c64edd67cea9b5a90698531ddb607"
+};
+function TOKENS() {
+  return getNetwork() === "base" ? BASE_TOKENS : BASE_SEPOLIA_TOKENS;
+}
+function MOONWELL() {
+  return getNetwork() === "base" ? BASE_MOONWELL : BASE_SEPOLIA_MOONWELL;
+}
+function UNISWAP() {
+  return getNetwork() === "base" ? BASE_UNISWAP : BASE_SEPOLIA_UNISWAP;
+}
+function ENS() {
+  return getNetwork() === "base" ? BASE_ENS : BASE_SEPOLIA_ENS;
+}
+function AGENT_REGISTRY() {
+  return getNetwork() === "base" ? BASE_AGENT_REGISTRY : BASE_SEPOLIA_AGENT_REGISTRY;
+}
+function VENICE() {
+  return getNetwork() === "base" ? BASE_VENICE : BASE_SEPOLIA_VENICE;
+}
+function SHERWOOD() {
+  return getNetwork() === "base" ? BASE_SHERWOOD : BASE_SEPOLIA_SHERWOOD;
+}
+function EAS_CONTRACTS() {
+  return getNetwork() === "base" ? BASE_EAS : BASE_SEPOLIA_EAS;
+}
+function EAS_SCHEMAS() {
+  return getNetwork() === "base" ? BASE_EAS_SCHEMAS : BASE_SEPOLIA_EAS_SCHEMAS;
+}
+
+// src/lib/config.ts
+import fs from "fs";
+import path from "path";
+import { getRandomValues } from "crypto";
+var CONFIG_DIR = path.join(process.env.HOME || "~", ".sherwood");
+var CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+function loadConfig() {
+  if (fs.existsSync(CONFIG_PATH)) {
+    return JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
+  }
+  const key = Buffer.from(getRandomValues(new Uint8Array(32))).toString("hex");
+  const config = { dbEncryptionKey: key, groupCache: {} };
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+  return config;
+}
+function saveConfig(config) {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+function cacheGroupId(subdomain, groupId) {
+  const config = loadConfig();
+  config.groupCache[subdomain] = groupId;
+  saveConfig(config);
+}
+function getCachedGroupId(subdomain) {
+  const config = loadConfig();
+  return config.groupCache[subdomain];
+}
+function setVeniceApiKey(apiKey) {
+  const config = loadConfig();
+  config.veniceApiKey = apiKey;
+  saveConfig(config);
+}
+function getVeniceApiKey() {
+  return loadConfig().veniceApiKey;
+}
+function setAgentId(agentId) {
+  const config = loadConfig();
+  config.agentId = agentId;
+  saveConfig(config);
+}
+function getAgentId() {
+  return loadConfig().agentId;
+}
+function setPrivateKey(key) {
+  const config = loadConfig();
+  config.privateKey = key.startsWith("0x") ? key : `0x${key}`;
+  saveConfig(config);
+}
+function getChainContracts(chainId) {
+  const config = loadConfig();
+  return config.contracts?.[String(chainId)] ?? {};
+}
+function setChainContract(chainId, key, value) {
+  const config = loadConfig();
+  if (!config.contracts) config.contracts = {};
+  const cid = String(chainId);
+  if (!config.contracts[cid]) config.contracts[cid] = {};
+  config.contracts[cid][key] = value;
+  saveConfig(config);
+}
+
+// src/lib/client.ts
+import { createPublicClient, createWalletClient, http } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+var _publicClient = null;
+var _walletClient = null;
+function getPrivateKey() {
+  const config = loadConfig();
+  if (config.privateKey) {
+    const k = config.privateKey;
+    return k.startsWith("0x") ? k : `0x${k}`;
+  }
+  const env = process.env.PRIVATE_KEY;
+  if (env) {
+    return env.startsWith("0x") ? env : `0x${env}`;
+  }
+  throw new Error(
+    "Private key not found. Run 'sherwood config set --private-key <key>' or set PRIVATE_KEY env var."
+  );
+}
+function getPublicClient() {
+  if (!_publicClient) {
+    _publicClient = createPublicClient({
+      chain: getChain(),
+      transport: http(getRpcUrl())
+    });
+  }
+  return _publicClient;
+}
+function getWalletClient() {
+  if (!_walletClient) {
+    const account = privateKeyToAccount(getPrivateKey());
+    _walletClient = createWalletClient({
+      account,
+      chain: getChain(),
+      transport: http(getRpcUrl())
+    });
+  }
+  return _walletClient;
+}
+function getAccount() {
+  return privateKeyToAccount(getPrivateKey());
+}
+
+// src/lib/abis.ts
+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: "totalAssets",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "asset",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }]
+  },
+  // ERC-20
+  {
+    name: "balanceOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  // LP
+  {
+    name: "ragequit",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "receiver", type: "address" }],
+    outputs: [{ name: "assets", type: "uint256" }]
+  },
+  // Batch execution (via delegatecall to shared executor lib)
+  {
+    name: "executeBatch",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      {
+        name: "calls",
+        type: "tuple[]",
+        components: [
+          { name: "target", type: "address" },
+          { name: "data", type: "bytes" },
+          { name: "value", type: "uint256" }
+        ]
+      },
+      { name: "assetAmount", type: "uint256" }
+    ],
+    outputs: []
+  },
+  {
+    name: "simulateBatch",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      {
+        name: "calls",
+        type: "tuple[]",
+        components: [
+          { name: "target", type: "address" },
+          { name: "data", type: "bytes" },
+          { name: "value", type: "uint256" }
+        ]
+      }
+    ],
+    outputs: [
+      {
+        name: "results",
+        type: "tuple[]",
+        components: [
+          { name: "success", type: "bool" },
+          { name: "returnData", type: "bytes" }
+        ]
+      }
+    ]
+  },
+  // Target allowlist
+  {
+    name: "addTarget",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "target", type: "address" }],
+    outputs: []
+  },
+  {
+    name: "addTargets",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "targets", type: "address[]" }],
+    outputs: []
+  },
+  {
+    name: "removeTarget",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "target", type: "address" }],
+    outputs: []
+  },
+  {
+    name: "isAllowedTarget",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "target", type: "address" }],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    name: "getAllowedTargets",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address[]" }]
+  },
+  // Agent management
+  {
+    name: "registerAgent",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "pkpAddress", type: "address" },
+      { name: "operatorEOA", type: "address" },
+      { name: "maxPerTx", type: "uint256" },
+      { name: "dailyLimit", type: "uint256" }
+    ],
+    outputs: []
+  },
+  {
+    name: "removeAgent",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "pkpAddress", type: "address" }],
+    outputs: []
+  },
+  // Views
+  {
+    name: "getAgentConfig",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "pkpAddress", type: "address" }],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        components: [
+          { name: "agentId", type: "uint256" },
+          { name: "pkpAddress", type: "address" },
+          { name: "operatorEOA", type: "address" },
+          { name: "maxPerTx", type: "uint256" },
+          { name: "dailyLimit", type: "uint256" },
+          { name: "spentToday", type: "uint256" },
+          { name: "lastResetDay", type: "uint256" },
+          { name: "active", type: "bool" }
+        ]
+      }
+    ]
+  },
+  {
+    name: "getSyndicateCaps",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        components: [
+          { name: "maxPerTx", type: "uint256" },
+          { name: "maxDailyTotal", type: "uint256" },
+          { name: "maxBorrowRatio", type: "uint256" }
+        ]
+      }
+    ]
+  },
+  {
+    name: "getAgentCount",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "getDailySpendTotal",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "isAgent",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "pkpAddress", type: "address" }],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    name: "getExecutorImpl",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }]
+  },
+  {
+    name: "totalDeposited",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "getAgentOperators",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address[]" }]
+  },
+  {
+    name: "pause",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [],
+    outputs: []
+  },
+  {
+    name: "unpause",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [],
+    outputs: []
+  },
+  // Depositor whitelist
+  {
+    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: "approveDepositors",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "depositors", type: "address[]" }],
+    outputs: []
+  },
+  {
+    name: "isApprovedDepositor",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "depositor", type: "address" }],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    name: "getApprovedDepositors",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address[]" }]
+  },
+  {
+    name: "setOpenDeposits",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "open", type: "bool" }],
+    outputs: []
+  },
+  {
+    name: "openDeposits",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  // ERC-4626 views for LP balance
+  {
+    name: "convertToAssets",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "shares", type: "uint256" }],
+    outputs: [{ name: "assets", type: "uint256" }]
+  },
+  {
+    name: "totalSupply",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  }
+];
+var UNISWAP_QUOTER_V2_ABI = [
+  {
+    name: "quoteExactInputSingle",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        components: [
+          { name: "tokenIn", type: "address" },
+          { name: "tokenOut", type: "address" },
+          { name: "amountIn", type: "uint256" },
+          { name: "fee", type: "uint24" },
+          { name: "sqrtPriceLimitX96", type: "uint160" }
+        ]
+      }
+    ],
+    outputs: [
+      { name: "amountOut", type: "uint256" },
+      { name: "sqrtPriceX96After", type: "uint160" },
+      { name: "initializedTicksCrossed", type: "uint32" },
+      { name: "gasEstimate", type: "uint256" }
+    ]
+  },
+  {
+    name: "quoteExactInput",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "path", type: "bytes" },
+      { name: "amountIn", type: "uint256" }
+    ],
+    outputs: [
+      { name: "amountOut", type: "uint256" },
+      { name: "sqrtPriceX96AfterList", type: "uint160[]" },
+      { name: "initializedTicksCrossedList", type: "uint32[]" },
+      { name: "gasEstimate", type: "uint256" }
+    ]
+  }
+];
+var ERC20_ABI = [
+  {
+    name: "approve",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    name: "balanceOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "allowance",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", 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" }]
+  },
+  {
+    name: "transfer",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  }
+];
+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: "caps",
+            type: "tuple",
+            components: [
+              { name: "maxPerTx", type: "uint256" },
+              { name: "maxDailyTotal", type: "uint256" },
+              { name: "maxBorrowRatio", type: "uint256" }
+            ]
+          },
+          { name: "initialTargets", type: "address[]" },
+          { name: "openDeposits", type: "bool" },
+          { name: "subdomain", type: "string" }
+        ]
+      }
+    ],
+    outputs: [
+      { name: "syndicateId", type: "uint256" },
+      { name: "vault", type: "address" }
+    ]
+  },
+  {
+    name: "syndicates",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "", 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: "getActiveSyndicates",
+    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" }
+        ]
+      }
+    ]
+  },
+  {
+    name: "syndicateCount",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "vaultToSyndicate",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "updateMetadata",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "syndicateId", type: "uint256" },
+      { name: "metadataURI", type: "string" }
+    ],
+    outputs: []
+  },
+  {
+    name: "deactivate",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "syndicateId", type: "uint256" }],
+    outputs: []
+  },
+  {
+    name: "executorImpl",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "address" }]
+  },
+  {
+    name: "vaultImpl",
+    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: "isSubdomainAvailable",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "subdomain", type: "string" }],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    name: "SyndicateCreated",
+    type: "event",
+    inputs: [
+      { name: "id", type: "uint256", indexed: true },
+      { name: "vault", type: "address", indexed: true },
+      { name: "creator", type: "address", indexed: true },
+      { name: "metadataURI", type: "string", indexed: false },
+      { name: "subdomain", type: "string", indexed: false }
+    ]
+  }
+];
+var L2_REGISTRY_ABI = [
+  {
+    name: "setText",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "node", type: "bytes32" },
+      { name: "key", type: "string" },
+      { name: "value", type: "string" }
+    ],
+    outputs: []
+  },
+  {
+    name: "text",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "node", type: "bytes32" },
+      { name: "key", type: "string" }
+    ],
+    outputs: [{ name: "", type: "string" }]
+  }
+];
+var STRATEGY_REGISTRY_ABI = [
+  {
+    name: "registerStrategy",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "implementation", type: "address" },
+      { name: "strategyTypeId", type: "uint256" },
+      { name: "name", type: "string" },
+      { name: "metadataURI", type: "string" }
+    ],
+    outputs: [{ name: "strategyId", type: "uint256" }]
+  },
+  {
+    name: "getStrategy",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "strategyId", type: "uint256" }],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        components: [
+          { name: "implementation", type: "address" },
+          { name: "creator", type: "address" },
+          { name: "strategyTypeId", type: "uint256" },
+          { name: "active", type: "bool" },
+          { name: "name", type: "string" },
+          { name: "metadataURI", type: "string" }
+        ]
+      }
+    ]
+  },
+  {
+    name: "getStrategiesByType",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "strategyTypeId", type: "uint256" }],
+    outputs: [{ name: "", type: "uint256[]" }]
+  },
+  {
+    name: "getStrategiesByCreator",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "creator", type: "address" }],
+    outputs: [{ name: "", type: "uint256[]" }]
+  },
+  {
+    name: "strategyCount",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "isStrategyActive",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "strategyId", type: "uint256" }],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    name: "deactivateStrategy",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "strategyId", type: "uint256" }],
+    outputs: []
+  }
+];
+var VENICE_STAKING_ABI = [
+  {
+    name: "stake",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "recipient", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: []
+  },
+  {
+    name: "initiateUnstake",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "amount", type: "uint256" }],
+    outputs: []
+  },
+  {
+    name: "finalizeUnstake",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [],
+    outputs: []
+  },
+  {
+    name: "mintDiem",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "sVVVAmountToLock", type: "uint256" },
+      { name: "minDiemAmountOut", type: "uint256" }
+    ],
+    outputs: []
+  },
+  {
+    name: "balanceOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "pendingRewards",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "_user", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "cooldownDuration",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "getDiemAmountOut",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "sVVVAmountToLock", type: "uint256" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "claim",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [],
+    outputs: []
+  }
+];
+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" }]
+  },
+  {
+    name: "revoke",
+    type: "function",
+    stateMutability: "payable",
+    inputs: [
+      {
+        name: "request",
+        type: "tuple",
+        components: [
+          { name: "schema", type: "bytes32" },
+          {
+            name: "data",
+            type: "tuple",
+            components: [
+              { name: "uid", type: "bytes32" },
+              { name: "value", type: "uint256" }
+            ]
+          }
+        ]
+      }
+    ],
+    outputs: []
+  },
+  {
+    name: "getAttestation",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "uid", type: "bytes32" }],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        components: [
+          { name: "uid", type: "bytes32" },
+          { name: "schema", type: "bytes32" },
+          { name: "time", type: "uint64" },
+          { name: "expirationTime", type: "uint64" },
+          { name: "revocationTime", type: "uint64" },
+          { name: "refUID", type: "bytes32" },
+          { name: "recipient", type: "address" },
+          { name: "attester", type: "address" },
+          { name: "revocable", type: "bool" },
+          { name: "data", type: "bytes" }
+        ]
+      }
+    ]
+  }
+];
+
+// src/lib/vault.ts
+import { formatUnits, encodeFunctionData, decodeFunctionResult } from "viem";
+var _vaultOverride = null;
+function setVaultAddress(addr) {
+  _vaultOverride = addr;
+}
+function getVaultAddress() {
+  if (_vaultOverride) return _vaultOverride;
+  const chainId = getChain().id;
+  const fromConfig = getChainContracts(chainId).vault;
+  if (fromConfig) return fromConfig;
+  throw new Error(
+    "Vault address not found. Pass --vault <addr> or run 'sherwood config set --vault <addr>'."
+  );
+}
+async function getAssetAddress() {
+  const client = getPublicClient();
+  return client.readContract({
+    address: getVaultAddress(),
+    abi: SYNDICATE_VAULT_ABI,
+    functionName: "asset"
+  });
+}
+async function getAssetDecimals() {
+  const client = getPublicClient();
+  const asset = await getAssetAddress();
+  return client.readContract({
+    address: asset,
+    abi: ERC20_ABI,
+    functionName: "decimals"
+  });
+}
+async function deposit(amount) {
+  const wallet = getWalletClient();
+  const vaultAddress = getVaultAddress();
+  const account = getAccount();
+  const asset = await getAssetAddress();
+  await wallet.writeContract({
+    account: getAccount(),
+    chain: getChain(),
+    address: asset,
+    abi: ERC20_ABI,
+    functionName: "approve",
+    args: [vaultAddress, amount]
+  });
+  return wallet.writeContract({
+    account: getAccount(),
+    chain: getChain(),
+    address: vaultAddress,
+    abi: SYNDICATE_VAULT_ABI,
+    functionName: "deposit",
+    args: [amount, account.address]
+  });
+}
+async function ragequit() {
+  const wallet = getWalletClient();
+  const account = getAccount();
+  return wallet.writeContract({
+    account: getAccount(),
+    chain: getChain(),
+    address: getVaultAddress(),
+    abi: SYNDICATE_VAULT_ABI,
+    functionName: "ragequit",
+    args: [account.address]
+  });
+}
+async function executeBatch(calls, assetAmount) {
+  const wallet = getWalletClient();
+  return wallet.writeContract({
+    account: getAccount(),
+    chain: getChain(),
+    address: getVaultAddress(),
+    abi: SYNDICATE_VAULT_ABI,
+    functionName: "executeBatch",
+    args: [
+      calls.map((c) => ({
+        target: c.target,
+        data: c.data,
+        value: c.value
+      })),
+      assetAmount
+    ]
+  });
+}
+async function simulateBatch(calls) {
+  const client = getPublicClient();
+  const vaultAddress = getVaultAddress();
+  const calldata = encodeFunctionData({
+    abi: SYNDICATE_VAULT_ABI,
+    functionName: "simulateBatch",
+    args: [
+      calls.map((c) => ({
+        target: c.target,
+        data: c.data,
+        value: c.value
+      }))
+    ]
+  });
+  const { data } = await client.call({
+    to: vaultAddress,
+    data: calldata
+  });
+  if (!data) {
+    throw new Error("simulateBatch returned no data");
+  }
+  const decoded = decodeFunctionResult({
+    abi: SYNDICATE_VAULT_ABI,
+    functionName: "simulateBatch",
+    data
+  });
+  return decoded.map((r) => ({
+    success: r.success,
+    returnData: r.returnData
+  }));
+}
+async function addTarget(target) {
+  const client = getWalletClient();
+  return client.writeContract({
+    account: getAccount(),
+    chain: getChain(),
+    address: getVaultAddress(),
+    abi: SYNDICATE_VAULT_ABI,
+    functionName: "addTarget",
+    args: [target]
+  });
+}
+async function removeTarget(target) {
+  const client = getWalletClient();
+  return client.writeContract({
+    account: getAccount(),
+    chain: getChain(),
+    address: getVaultAddress(),
+    abi: SYNDICATE_VAULT_ABI,
+    functionName: "removeTarget",
+    args: [target]
+  });
+}
+async function getAllowedTargets() {
+  const client = getPublicClient();
+  return client.readContract({
+    address: getVaultAddress(),
+    abi: SYNDICATE_VAULT_ABI,
+    functionName: "getAllowedTargets"
+  });
+}
+async function approveDepositor(depositor) {
+  const wallet = getWalletClient();
+  return wallet.writeContract({
+    account: getAccount(),
+    chain: getChain(),
+    address: getVaultAddress(),
+    abi: SYNDICATE_VAULT_ABI,
+    functionName: "approveDepositor",
+    args: [depositor]
+  });
+}
+async function removeDepositor(depositor) {
+  const wallet = getWalletClient();
+  return wallet.writeContract({
+    account: getAccount(),
+    chain: getChain(),
+    address: getVaultAddress(),
+    abi: SYNDICATE_VAULT_ABI,
+    functionName: "removeDepositor",
+    args: [depositor]
+  });
+}
+async function getBalance(address) {
+  const client = getPublicClient();
+  const vaultAddress = getVaultAddress();
+  const account = address || getAccount().address;
+  const [shares, totalSupply] = await Promise.all([
+    client.readContract({
+      address: vaultAddress,
+      abi: SYNDICATE_VAULT_ABI,
+      functionName: "balanceOf",
+      args: [account]
+    }),
+    client.readContract({
+      address: vaultAddress,
+      abi: SYNDICATE_VAULT_ABI,
+      functionName: "totalSupply"
+    })
+  ]);
+  let assetsValue = 0n;
+  if (shares > 0n) {
+    assetsValue = await client.readContract({
+      address: vaultAddress,
+      abi: SYNDICATE_VAULT_ABI,
+      functionName: "convertToAssets",
+      args: [shares]
+    });
+  }
+  const percent = totalSupply > 0n ? (Number(shares) / Number(totalSupply) * 100).toFixed(2) : "0.00";
+  const decimals = await getAssetDecimals();
+  return {
+    shares,
+    assetsValue: formatUnits(assetsValue, decimals),
+    percentOfVault: `${percent}%`
+  };
+}
+async function registerAgent(agentId, pkpAddress, operatorEOA, maxPerTx, dailyLimit) {
+  const wallet = getWalletClient();
+  return wallet.writeContract({
+    account: getAccount(),
+    chain: getChain(),
+    address: getVaultAddress(),
+    abi: SYNDICATE_VAULT_ABI,
+    functionName: "registerAgent",
+    args: [agentId, pkpAddress, operatorEOA, maxPerTx, dailyLimit]
+  });
+}
+async function getVaultInfo() {
+  const client = getPublicClient();
+  const vaultAddress = getVaultAddress();
+  const [totalAssets, caps, agentCount, dailySpend, decimals] = await Promise.all([
+    client.readContract({
+      address: vaultAddress,
+      abi: SYNDICATE_VAULT_ABI,
+      functionName: "totalAssets"
+    }),
+    client.readContract({
+      address: vaultAddress,
+      abi: SYNDICATE_VAULT_ABI,
+      functionName: "getSyndicateCaps"
+    }),
+    client.readContract({
+      address: vaultAddress,
+      abi: SYNDICATE_VAULT_ABI,
+      functionName: "getAgentCount"
+    }),
+    client.readContract({
+      address: vaultAddress,
+      abi: SYNDICATE_VAULT_ABI,
+      functionName: "getDailySpendTotal"
+    }),
+    getAssetDecimals()
+  ]);
+  return {
+    address: vaultAddress,
+    totalAssets: formatUnits(totalAssets, decimals),
+    syndicateCaps: {
+      maxPerTx: formatUnits(caps.maxPerTx, decimals),
+      maxDailyTotal: formatUnits(caps.maxDailyTotal, decimals),
+      maxBorrowRatio: `${(Number(caps.maxBorrowRatio) / 100).toFixed(1)}%`
+    },
+    agentCount,
+    dailySpendTotal: formatUnits(dailySpend, decimals)
+  };
+}
+
+// src/lib/ens.ts
+import { encodeFunctionData as encodeFunctionData2 } from "viem";
+import { namehash } from "viem/ens";
+async function waitForTx(hash) {
+  const client = getPublicClient();
+  await client.waitForTransactionReceipt({ hash });
+}
+var ENS_DOMAIN = "sherwoodagent.eth";
+function getFactoryAddress() {
+  return SHERWOOD().FACTORY;
+}
+async function resolveSyndicate(subdomain) {
+  const client = getPublicClient();
+  const factory = getFactoryAddress();
+  const syndicateId = await client.readContract({
+    address: factory,
+    abi: SYNDICATE_FACTORY_ABI,
+    functionName: "subdomainToSyndicate",
+    args: [subdomain]
+  });
+  if (syndicateId === 0n) {
+    throw new Error(`Syndicate "${subdomain}" not found`);
+  }
+  const result = await client.readContract({
+    address: factory,
+    abi: SYNDICATE_FACTORY_ABI,
+    functionName: "syndicates",
+    args: [syndicateId]
+  });
+  return {
+    id: result[0],
+    vault: result[1],
+    creator: result[2],
+    subdomain: result[6]
+  };
+}
+async function resolveVaultSyndicate(vaultAddress) {
+  const client = getPublicClient();
+  const factory = getFactoryAddress();
+  const syndicateId = await client.readContract({
+    address: factory,
+    abi: SYNDICATE_FACTORY_ABI,
+    functionName: "vaultToSyndicate",
+    args: [vaultAddress]
+  });
+  if (syndicateId === 0n) {
+    throw new Error(`No syndicate found for vault ${vaultAddress}`);
+  }
+  const result = await client.readContract({
+    address: factory,
+    abi: SYNDICATE_FACTORY_ABI,
+    functionName: "syndicates",
+    args: [syndicateId]
+  });
+  return {
+    id: result[0],
+    vault: result[1],
+    creator: result[2],
+    subdomain: result[6]
+  };
+}
+function getSubdomainNode(subdomain) {
+  return namehash(`${subdomain}.${ENS_DOMAIN}`);
+}
+async function setTextRecord(subdomain, key, value, vaultAddress) {
+  const l2Registry = ENS().L2_REGISTRY;
+  const node = getSubdomainNode(subdomain);
+  setVaultAddress(vaultAddress);
+  try {
+    const addTargetHash = await addTarget(l2Registry);
+    await waitForTx(addTargetHash);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (!msg.includes("0xff0e53f8") && !msg.includes("TargetAlreadyAllowed")) {
+      throw err;
+    }
+  }
+  const setTextData = encodeFunctionData2({
+    abi: L2_REGISTRY_ABI,
+    functionName: "setText",
+    args: [node, key, value]
+  });
+  return executeBatch(
+    [{ target: l2Registry, data: setTextData, value: 0n }],
+    0n
+  );
+}
+async function getTextRecord(subdomain, key) {
+  const client = getPublicClient();
+  const node = getSubdomainNode(subdomain);
+  return client.readContract({
+    address: ENS().L2_REGISTRY,
+    abi: L2_REGISTRY_ABI,
+    functionName: "text",
+    args: [node, key]
+  });
+}
+
+export {
+  setNetwork,
+  getNetwork,
+  getChain,
+  getRpcUrl,
+  getExplorerUrl,
+  TOKENS,
+  MOONWELL,
+  UNISWAP,
+  AGENT_REGISTRY,
+  VENICE,
+  SHERWOOD,
+  EAS_CONTRACTS,
+  EAS_SCHEMAS,
+  loadConfig,
+  saveConfig,
+  cacheGroupId,
+  getCachedGroupId,
+  setVeniceApiKey,
+  getVeniceApiKey,
+  setAgentId,
+  getAgentId,
+  setPrivateKey,
+  getChainContracts,
+  setChainContract,
+  getPublicClient,
+  getWalletClient,
+  getAccount,
+  SYNDICATE_VAULT_ABI,
+  UNISWAP_QUOTER_V2_ABI,
+  ERC20_ABI,
+  SYNDICATE_FACTORY_ABI,
+  STRATEGY_REGISTRY_ABI,
+  VENICE_STAKING_ABI,
+  EAS_ABI,
+  setVaultAddress,
+  getVaultAddress,
+  getAssetDecimals,
+  deposit,
+  ragequit,
+  executeBatch,
+  simulateBatch,
+  addTarget,
+  removeTarget,
+  getAllowedTargets,
+  approveDepositor,
+  removeDepositor,
+  getBalance,
+  registerAgent,
+  getVaultInfo,
+  resolveSyndicate,
+  resolveVaultSyndicate,
+  setTextRecord,
+  getTextRecord
+};
+//# sourceMappingURL=chunk-CR3ZNOB7.js.map