web3agent 0.1.0 → 0.2.0

package/dist/goat-XA66K7CZ.js

@@ -0,0 +1,303 @@
+import {
+  RESTRICTED_PLUGIN_CHAINS,
+  Web3AgentError,
+  assertAddress,
+  assertChainSupported,
+  buildGoatTools,
+  createPublicClientForRuntimeChain,
+  findRestrictedPlugin,
+  getChainForRuntime,
+  getConfirmedReceipt,
+  getRpcUrlForRuntimeChain,
+  getRuntimeConfigForChain,
+  loadPlugins,
+  lookupTokenByAddress
+} from "./chunk-BJUU5ESI.js";
+import "./chunk-KPRIUALX.js";
+import "./chunk-7QEKU2RP.js";
+
+// src/operations/goat-wallet.ts
+import { encodeFunctionData, parseAbi } from "viem";
+var erc20BalanceAbi = parseAbi(["function balanceOf(address account) view returns (uint256)"]);
+function normalizeTypedDataTypes(types) {
+  const normalized = {};
+  for (const [typeName, entries] of Object.entries(types)) {
+    if (!Array.isArray(entries)) {
+      throw new Web3AgentError({
+        code: "GOAT_TOOL_ERROR",
+        message: `Typed data type ${typeName} must be an array`
+      });
+    }
+    normalized[typeName] = entries.map((entry, index) => {
+      if (!entry || typeof entry !== "object") {
+        throw new Web3AgentError({
+          code: "GOAT_TOOL_ERROR",
+          message: `Typed data entry ${typeName}[${index}] must be an object`
+        });
+      }
+      const name = entry.name;
+      const type = entry.type;
+      if (typeof name !== "string" || typeof type !== "string") {
+        throw new Web3AgentError({
+          code: "GOAT_TOOL_ERROR",
+          message: `Typed data entry ${typeName}[${index}] must include string name/type`
+        });
+      }
+      return { name, type };
+    });
+  }
+  return normalized;
+}
+var OperationPauseError = class extends Error {
+  constructor(action) {
+    super(`Operation paused for ${action.type}`);
+    this.action = action;
+    this.name = "OperationPauseError";
+  }
+};
+var PreparedActionGoatWallet = class {
+  constructor(options) {
+    this.options = options;
+    const chain = getChainForRuntime(this.options.chainId);
+    this.publicClient = createPublicClientForRuntimeChain(this.options.chainId);
+    this.chain = {
+      type: "evm",
+      id: chain.id,
+      nativeCurrency: chain.nativeCurrency
+    };
+  }
+  publicClient;
+  chain;
+  transactionIndex = 0;
+  signTypedDataIndex = 0;
+  signMessageIndex = 0;
+  getAddress() {
+    return assertAddress(this.options.account, "account");
+  }
+  getChain() {
+    return this.chain;
+  }
+  getCoreTools() {
+    return [];
+  }
+  async signMessage(message) {
+    const id = `sign-message:${this.signMessageIndex++}`;
+    const result = this.options.actionResults[id];
+    if (result?.type === "signature" || result?.type === "messageSignature") {
+      return { signature: result.signature };
+    }
+    throw new OperationPauseError({
+      id,
+      type: "signMessage",
+      label: "Sign message",
+      chainId: this.options.chainId,
+      message
+    });
+  }
+  async signTypedData(data) {
+    const id = `sign-typed-data:${this.signTypedDataIndex++}`;
+    const result = this.options.actionResults[id];
+    if (result?.type === "signature") {
+      return { signature: result.signature };
+    }
+    throw new OperationPauseError({
+      id,
+      type: "signTypedData",
+      label: "Sign typed data",
+      chainId: this.options.chainId,
+      eip712: {
+        domain: data.domain,
+        types: normalizeTypedDataTypes(data.types),
+        primaryType: data.primaryType,
+        message: data.message
+      }
+    });
+  }
+  async sendTransaction(transaction) {
+    const id = `transaction:${this.transactionIndex++}`;
+    const result = this.options.actionResults[id];
+    if (result?.type === "transaction") {
+      const to2 = assertAddress(transaction.to, "transaction.to");
+      const action = {
+        id,
+        type: "transaction",
+        label: `Execute transaction to ${to2}`,
+        tx: {
+          to: to2,
+          chainId: this.options.chainId
+        }
+      };
+      await getConfirmedReceipt(action, result);
+      return { hash: result.txHash };
+    }
+    const to = assertAddress(transaction.to, "transaction.to");
+    const data = transaction.data ?? (transaction.abi && transaction.functionName ? encodeFunctionData({
+      abi: transaction.abi,
+      functionName: transaction.functionName,
+      args: transaction.args
+    }) : void 0);
+    throw new OperationPauseError({
+      id,
+      type: "transaction",
+      label: transaction.functionName ? `Execute ${transaction.functionName}` : `Execute transaction to ${to}`,
+      tx: {
+        to,
+        chainId: this.options.chainId,
+        ...data ? { data } : {},
+        ...transaction.value !== void 0 ? { value: transaction.value.toString() } : {}
+      }
+    });
+  }
+  async read(request) {
+    const value = await this.publicClient.readContract({
+      address: assertAddress(request.address, "read.address"),
+      abi: request.abi,
+      functionName: request.functionName,
+      ...request.args ? { args: request.args } : {}
+    });
+    return { value };
+  }
+  async getNativeBalance() {
+    return this.publicClient.getBalance({
+      address: this.getAddress()
+    });
+  }
+  async balanceOf(address, tokenAddress) {
+    if (!tokenAddress) {
+      const value = await this.publicClient.getBalance({
+        address: assertAddress(address, "address")
+      });
+      return {
+        value: value.toString(),
+        decimals: this.chain.nativeCurrency.decimals,
+        symbol: this.chain.nativeCurrency.symbol,
+        name: this.chain.nativeCurrency.name,
+        inBaseUnits: value.toString()
+      };
+    }
+    const normalizedTokenAddress = assertAddress(tokenAddress, "tokenAddress");
+    const tokenBalance = await this.publicClient.readContract({
+      address: normalizedTokenAddress,
+      abi: erc20BalanceAbi,
+      functionName: "balanceOf",
+      args: [assertAddress(address, "address")]
+    });
+    const token = lookupTokenByAddress(normalizedTokenAddress, this.options.chainId);
+    return {
+      value: tokenBalance.toString(),
+      decimals: token?.decimals ?? 18,
+      symbol: token?.symbol ?? "UNKNOWN",
+      name: token?.name ?? "Unknown Token",
+      inBaseUnits: tokenBalance.toString()
+    };
+  }
+  async getTokenInfoByTicker(ticker) {
+    const toolHint = this.options.toolName ? ` (triggered by ${this.options.toolName})` : "";
+    throw new Web3AgentError({
+      code: "GOAT_TOOL_ERROR",
+      message: `Token lookup by ticker is not supported in prepared GOAT mode (${ticker})${toolHint}; resolve token addresses before running prepared GOAT tools`
+    });
+  }
+};
+
+// src/operations/goat.ts
+function assertGoatToolSupportedOnChain(toolName, chainId) {
+  assertChainSupported(chainId);
+  const pluginKey = findRestrictedPlugin(toolName);
+  if (!pluginKey) return;
+  const availableChains = RESTRICTED_PLUGIN_CHAINS[pluginKey];
+  if (!availableChains.includes(chainId)) {
+    throw new Web3AgentError({
+      code: "TOOL_UNAVAILABLE_ON_CHAIN",
+      message: `${toolName} is not available on chain ${chainId}. Available on chains: ${availableChains.join(", ")}`,
+      details: { availableChainIds: availableChains }
+    });
+  }
+}
+function toCompletedResult(result) {
+  if (result && typeof result === "object" && !Array.isArray(result)) {
+    return result;
+  }
+  return {
+    value: result
+  };
+}
+function loadGoatPluginsForChain(chainId) {
+  const config = getRuntimeConfigForChain(chainId);
+  return loadPlugins({
+    hasWallet: true,
+    zeroxApiKey: config.zeroxApiKey,
+    coingeckoApiKey: config.coingeckoApiKey,
+    rpcUrl: getRpcUrlForRuntimeChain(chainId, config)
+  });
+}
+function createGoatPreparedOperation(params) {
+  const { input, tool, actionResults, pause } = params;
+  return {
+    integration: "goat",
+    kind: "tool",
+    summary: tool.description || `Prepare GOAT tool ${tool.name} on chain ${input.chainId}`,
+    actions: [pause.action],
+    resumeState: {
+      version: 1,
+      integration: "goat",
+      kind: "tool",
+      state: {
+        toolName: input.toolName,
+        params: input.params ?? {},
+        chainId: input.chainId,
+        account: input.account,
+        actionResults
+      }
+    },
+    meta: {
+      toolName: tool.name,
+      description: tool.description
+    }
+  };
+}
+async function prepareOrResumeGoatOperation(params) {
+  const actionResults = params.actionResults ?? {};
+  assertGoatToolSupportedOnChain(params.input.toolName, params.input.chainId);
+  const pluginResult = loadGoatPluginsForChain(params.input.chainId);
+  const wallet = new PreparedActionGoatWallet({
+    account: params.input.account,
+    chainId: params.input.chainId,
+    actionResults,
+    toolName: params.input.toolName
+  });
+  const tools = await buildGoatTools({
+    wallet,
+    pluginResult
+  });
+  const executableTool = tools.find((candidate) => candidate.name === params.input.toolName);
+  if (!executableTool) {
+    throw new Web3AgentError({
+      code: "UNKNOWN_TOOL",
+      message: `Unknown GOAT tool: ${params.input.toolName}`
+    });
+  }
+  try {
+    const parsed = executableTool.parameters.parse(params.input.params ?? {});
+    const result = await executableTool.execute(parsed);
+    return {
+      completed: true,
+      integration: "goat",
+      kind: "tool",
+      result: toCompletedResult(result)
+    };
+  } catch (error) {
+    if (error instanceof OperationPauseError) {
+      return createGoatPreparedOperation({
+        input: params.input,
+        tool: executableTool,
+        actionResults,
+        pause: error
+      });
+    }
+    throw Web3AgentError.fromUnknown("GOAT_TOOL_ERROR", error);
+  }
+}
+export {
+  prepareOrResumeGoatOperation
+};