@sherwoodagent/cli 0.5.1 → 0.7.0

package/dist/{chunk-3WZLP6BH.js → chunk-FGSXRXCZ.js}

@@ -1,25 +1,6 @@
-// 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}`;
-}
+import {
+  getNetwork
+} from "./chunk-QMWMT6EH.js";
 
 // src/lib/addresses.ts
 var BASE_TOKENS = {
@@ -124,11 +105,13 @@ var BASE_SEPOLIA_EAS = {
 };
 var BASE_EAS_SCHEMAS = {
   SYNDICATE_JOIN_REQUEST: "0x0000000000000000000000000000000000000000000000000000000000000000",
-  AGENT_APPROVED: "0x0000000000000000000000000000000000000000000000000000000000000000"
+  AGENT_APPROVED: "0x0000000000000000000000000000000000000000000000000000000000000000",
+  X402_RESEARCH: "0x0000000000000000000000000000000000000000000000000000000000000000"
 };
 var BASE_SEPOLIA_EAS_SCHEMAS = {
   SYNDICATE_JOIN_REQUEST: "0x1e7ce17b16233977ba913b156033e98f52029f4bee273a4abefe6c15ce11d5ef",
-  AGENT_APPROVED: "0x1013f7b38f433b2a93fc5ac162482813081c64edd67cea9b5a90698531ddb607"
+  AGENT_APPROVED: "0x1013f7b38f433b2a93fc5ac162482813081c64edd67cea9b5a90698531ddb607",
+  X402_RESEARCH: "0x0000000000000000000000000000000000000000000000000000000000000000"
 };
 function TOKENS() {
   return getNetwork() === "base" ? BASE_TOKENS : BASE_SEPOLIA_TOKENS;
@@ -158,110 +141,6 @@ 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";
-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 config = { 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
@@ -501,6 +380,50 @@ var SYNDICATE_VAULT_ABI = [
     inputs: [],
     outputs: [{ name: "", type: "uint256" }]
   },
+  // ── Events ──
+  {
+    name: "AgentRegistered",
+    type: "event",
+    inputs: [
+      { name: "agentId", type: "uint256", indexed: true },
+      { name: "pkpAddress", type: "address", indexed: true },
+      { name: "operatorEOA", type: "address", indexed: true }
+    ]
+  },
+  {
+    name: "AgentRemoved",
+    type: "event",
+    inputs: [{ name: "pkpAddress", type: "address", indexed: true }]
+  },
+  {
+    name: "Ragequit",
+    type: "event",
+    inputs: [
+      { name: "lp", type: "address", indexed: true },
+      { name: "shares", type: "uint256", indexed: false },
+      { name: "assets", type: "uint256", indexed: false }
+    ]
+  },
+  {
+    name: "DepositorApproved",
+    type: "event",
+    inputs: [{ name: "depositor", type: "address", indexed: true }]
+  },
+  {
+    name: "DepositorRemoved",
+    type: "event",
+    inputs: [{ name: "depositor", type: "address", indexed: true }]
+  },
+  {
+    name: "RedemptionsLockedEvent",
+    type: "event",
+    inputs: []
+  },
+  {
+    name: "RedemptionsUnlockedEvent",
+    type: "event",
+    inputs: []
+  },
   // Governor integration
   {
     name: "governor",
@@ -997,371 +920,23 @@ var EAS_ABI = [
   }
 ];
 
-// 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 client = getPublicClient();
-  const vaultAddress = getVaultAddress();
-  const account = getAccount();
-  const asset = await getAssetAddress();
-  const approveHash = await wallet.writeContract({
-    account: getAccount(),
-    chain: getChain(),
-    address: asset,
-    abi: ERC20_ABI,
-    functionName: "approve",
-    args: [vaultAddress, amount]
-  });
-  await client.waitForTransactionReceipt({ hash: approveHash });
-  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) {
-  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
-      }))
-    ]
-  });
-}
-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 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 isAgent(pkpAddress) {
-  const client = getPublicClient();
-  return client.readContract({
-    address: getVaultAddress(),
-    abi: SYNDICATE_VAULT_ABI,
-    functionName: "isAgent",
-    args: [pkpAddress]
-  });
-}
-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) {
-  const wallet = getWalletClient();
-  const client = getPublicClient();
-  const hash = await wallet.writeContract({
-    account: getAccount(),
-    chain: getChain(),
-    address: getVaultAddress(),
-    abi: SYNDICATE_VAULT_ABI,
-    functionName: "registerAgent",
-    args: [agentId, pkpAddress, operatorEOA]
-  });
-  await client.waitForTransactionReceipt({ hash });
-  return hash;
-}
-async function getVaultInfo() {
-  const client = getPublicClient();
-  const vaultAddress = getVaultAddress();
-  const [totalAssets, agentCount, redemptionsLocked, managementFeeBps, decimals] = await Promise.all([
-    client.readContract({
-      address: vaultAddress,
-      abi: SYNDICATE_VAULT_ABI,
-      functionName: "totalAssets"
-    }),
-    client.readContract({
-      address: vaultAddress,
-      abi: SYNDICATE_VAULT_ABI,
-      functionName: "getAgentCount"
-    }),
-    client.readContract({
-      address: vaultAddress,
-      abi: SYNDICATE_VAULT_ABI,
-      functionName: "redemptionsLocked"
-    }),
-    client.readContract({
-      address: vaultAddress,
-      abi: SYNDICATE_VAULT_ABI,
-      functionName: "managementFeeBps"
-    }),
-    getAssetDecimals()
-  ]);
-  return {
-    address: vaultAddress,
-    totalAssets: formatUnits(totalAssets, decimals),
-    agentCount,
-    redemptionsLocked,
-    managementFeeBps
-  };
-}
-
-// src/lib/ens.ts
-import { encodeFunctionData as encodeFunctionData2 } from "viem";
-import { namehash } from "viem/ens";
-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);
-  const setTextData = encodeFunctionData2({
-    abi: L2_REGISTRY_ABI,
-    functionName: "setText",
-    args: [node, key, value]
-  });
-  return executeBatch(
-    [{ target: l2Registry, data: setTextData, value: 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,
+  ENS,
   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,
+  L2_REGISTRY_ABI,
   STRATEGY_REGISTRY_ABI,
   VENICE_STAKING_ABI,
-  EAS_ABI,
-  setVaultAddress,
-  getVaultAddress,
-  getAssetDecimals,
-  deposit,
-  ragequit,
-  executeBatch,
-  simulateBatch,
-  approveDepositor,
-  removeDepositor,
-  isAgent,
-  getBalance,
-  registerAgent,
-  getVaultInfo,
-  resolveSyndicate,
-  resolveVaultSyndicate,
-  setTextRecord,
-  getTextRecord
+  EAS_ABI
 };
-//# sourceMappingURL=chunk-3WZLP6BH.js.map
+//# sourceMappingURL=chunk-FGSXRXCZ.js.map