@vleap/warps-adapter-evm 0.2.0-alpha.10

package/dist/index.mjs

@@ -0,0 +1,1073 @@
+// src/WarpEvmDataLoader.ts
+import { ethers } from "ethers";
+
+// src/config.ts
+var EVM_CHAIN_CONFIGS = {
+  ethereum: {
+    mainnet: {
+      apiUrl: "https://eth-mainnet.g.alchemy.com/v2/demo",
+      explorerUrl: "https://etherscan.io",
+      chainId: "1",
+      registryAddress: "0x0000000000000000000000000000000000000000",
+      nativeToken: "ETH",
+      blockTime: 12e3
+    },
+    testnet: {
+      apiUrl: "https://eth-sepolia.g.alchemy.com/v2/demo",
+      explorerUrl: "https://sepolia.etherscan.io",
+      chainId: "11155111",
+      registryAddress: "0x0000000000000000000000000000000000000000",
+      nativeToken: "ETH",
+      blockTime: 12e3
+    },
+    devnet: {
+      apiUrl: "http://localhost:8545",
+      explorerUrl: "http://localhost:4000",
+      chainId: "1337",
+      registryAddress: "0x0000000000000000000000000000000000000000",
+      nativeToken: "ETH",
+      blockTime: 12e3
+    }
+  },
+  arbitrum: {
+    mainnet: {
+      apiUrl: "https://arb-mainnet.g.alchemy.com/v2/demo",
+      explorerUrl: "https://arbiscan.io",
+      chainId: "42161",
+      registryAddress: "0x0000000000000000000000000000000000000000",
+      nativeToken: "ETH",
+      blockTime: 1e3
+    },
+    testnet: {
+      apiUrl: "https://arb-sepolia.g.alchemy.com/v2/demo",
+      explorerUrl: "https://sepolia.arbiscan.io",
+      chainId: "421614",
+      registryAddress: "0x0000000000000000000000000000000000000000",
+      nativeToken: "ETH",
+      blockTime: 1e3
+    },
+    devnet: {
+      apiUrl: "http://localhost:8545",
+      explorerUrl: "http://localhost:4000",
+      chainId: "1337",
+      registryAddress: "0x0000000000000000000000000000000000000000",
+      nativeToken: "ETH",
+      blockTime: 1e3
+    }
+  },
+  base: {
+    mainnet: {
+      apiUrl: "https://mainnet.base.org",
+      explorerUrl: "https://basescan.org",
+      chainId: "8453",
+      registryAddress: "0x0000000000000000000000000000000000000000",
+      nativeToken: "ETH",
+      blockTime: 2e3
+    },
+    testnet: {
+      apiUrl: "https://sepolia.base.org",
+      explorerUrl: "https://sepolia.basescan.org",
+      chainId: "84532",
+      registryAddress: "0x0000000000000000000000000000000000000000",
+      nativeToken: "ETH",
+      blockTime: 2e3
+    },
+    devnet: {
+      apiUrl: "http://localhost:8545",
+      explorerUrl: "http://localhost:4000",
+      chainId: "1337",
+      registryAddress: "0x0000000000000000000000000000000000000000",
+      nativeToken: "ETH",
+      blockTime: 2e3
+    }
+  }
+};
+var DEFAULT_CHAIN = "ethereum";
+var getEvmChainConfig = (chain = DEFAULT_CHAIN, env) => {
+  const chainConfigs = EVM_CHAIN_CONFIGS[chain];
+  if (!chainConfigs) {
+    throw new Error(`Unsupported EVM chain: ${chain}`);
+  }
+  const config = chainConfigs[env];
+  if (!config) {
+    throw new Error(`Unsupported environment ${env} for chain ${chain}`);
+  }
+  return config;
+};
+var getEvmApiUrl = (env, chain = DEFAULT_CHAIN) => {
+  return getEvmChainConfig(chain, env).apiUrl;
+};
+var getEvmExplorerUrl = (env, chain = DEFAULT_CHAIN) => {
+  return getEvmChainConfig(chain, env).explorerUrl;
+};
+
+// src/WarpEvmDataLoader.ts
+var ERC20_ABI = [
+  "function balanceOf(address owner) view returns (uint256)",
+  "function decimals() view returns (uint8)",
+  "function name() view returns (string)",
+  "function symbol() view returns (string)",
+  "function totalSupply() view returns (uint256)"
+];
+var KNOWN_TOKENS = {
+  ethereum: {
+    "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": {
+      name: "USD Coin",
+      symbol: "USDC",
+      decimals: 6,
+      logoUrl: "https://assets.coingecko.com/coins/images/6319/small/USD_Coin_icon.png"
+    },
+    "0xdAC17F958D2ee523a2206206994597C13D831ec7": {
+      name: "Tether USD",
+      symbol: "USDT",
+      decimals: 6,
+      logoUrl: "https://assets.coingecko.com/coins/images/325/small/Tether.png"
+    },
+    "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599": {
+      name: "Wrapped Bitcoin",
+      symbol: "WBTC",
+      decimals: 8,
+      logoUrl: "https://assets.coingecko.com/coins/images/7598/small/wrapped_bitcoin_wbtc.png"
+    },
+    "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2": {
+      name: "Wrapped Ether",
+      symbol: "WETH",
+      decimals: 18,
+      logoUrl: "https://assets.coingecko.com/coins/images/2518/small/weth.png"
+    },
+    "0x6B175474E89094C44Da98b954EedeAC495271d0F": {
+      name: "Dai Stablecoin",
+      symbol: "DAI",
+      decimals: 18,
+      logoUrl: "https://assets.coingecko.com/coins/images/9956/small/4943.png"
+    }
+  },
+  arbitrum: {
+    "0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8": {
+      name: "USD Coin",
+      symbol: "USDC",
+      decimals: 6,
+      logoUrl: "https://assets.coingecko.com/coins/images/6319/small/USD_Coin_icon.png"
+    },
+    "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9": {
+      name: "Tether USD",
+      symbol: "USDT",
+      decimals: 6,
+      logoUrl: "https://assets.coingecko.com/coins/images/325/small/Tether.png"
+    },
+    "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1": {
+      name: "Wrapped Ether",
+      symbol: "WETH",
+      decimals: 18,
+      logoUrl: "https://assets.coingecko.com/coins/images/2518/small/weth.png"
+    }
+  },
+  base: {
+    "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913": {
+      name: "USD Coin",
+      symbol: "USDC",
+      decimals: 6,
+      logoUrl: "https://assets.coingecko.com/coins/images/6319/small/USD_Coin_icon.png"
+    },
+    "0x4200000000000000000000000000000000000006": {
+      name: "Wrapped Ether",
+      symbol: "WETH",
+      decimals: 18,
+      logoUrl: "https://assets.coingecko.com/coins/images/2518/small/weth.png"
+    }
+  }
+};
+var WarpEvmDataLoader = class {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    this.provider = new ethers.JsonRpcProvider(getEvmApiUrl(this.config.env, this.chain.name));
+    this.chainConfig = getEvmChainConfig(this.chain.name, this.config.env);
+  }
+  async getAccount(address) {
+    try {
+      const balance = await this.provider.getBalance(address);
+      return {
+        address,
+        balance
+      };
+    } catch (error) {
+      throw new Error(`Failed to get account balance for ${address}: ${error}`);
+    }
+  }
+  async getAccountAssets(address) {
+    try {
+      const assets = [];
+      const tokenBalances = await this.getERC20TokenBalances(address);
+      for (const tokenBalance of tokenBalances) {
+        if (tokenBalance.balance > 0n) {
+          assets.push({
+            identifier: tokenBalance.tokenAddress,
+            name: tokenBalance.metadata.name,
+            amount: tokenBalance.balance,
+            decimals: tokenBalance.metadata.decimals,
+            logoUrl: tokenBalance.metadata.logoUrl || ""
+          });
+        }
+      }
+      return assets;
+    } catch (error) {
+      throw new Error(`Failed to get account assets for ${address}: ${error}`);
+    }
+  }
+  async getERC20TokenBalances(address) {
+    const tokenBalances = [];
+    const knownTokens = KNOWN_TOKENS[this.chain.name] || {};
+    for (const [tokenAddress, metadata] of Object.entries(knownTokens)) {
+      try {
+        const balance = await this.getTokenBalance(address, tokenAddress);
+        if (balance > 0n) {
+          tokenBalances.push({
+            tokenAddress,
+            balance,
+            metadata
+          });
+        }
+      } catch (error) {
+        console.warn(`Failed to get balance for token ${tokenAddress}: ${error}`);
+      }
+    }
+    const additionalTokens = await this.detectTokensFromEvents(address);
+    for (const tokenAddress of additionalTokens) {
+      if (!knownTokens[tokenAddress]) {
+        try {
+          const metadata = await this.getTokenMetadata(tokenAddress);
+          const balance = await this.getTokenBalance(address, tokenAddress);
+          if (balance > 0n) {
+            tokenBalances.push({
+              tokenAddress,
+              balance,
+              metadata
+            });
+          }
+        } catch (error) {
+          console.warn(`Failed to get metadata/balance for detected token ${tokenAddress}: ${error}`);
+        }
+      }
+    }
+    return tokenBalances;
+  }
+  async getTokenBalance(address, tokenAddress) {
+    try {
+      const contract = new ethers.Contract(tokenAddress, ERC20_ABI, this.provider);
+      const balance = await contract.balanceOf(address);
+      return balance;
+    } catch (error) {
+      throw new Error(`Failed to get token balance: ${error}`);
+    }
+  }
+  async getTokenMetadata(tokenAddress) {
+    try {
+      const contract = new ethers.Contract(tokenAddress, ERC20_ABI, this.provider);
+      const [name, symbol, decimals] = await Promise.all([contract.name(), contract.symbol(), contract.decimals()]);
+      return {
+        name: name || "Unknown Token",
+        symbol: symbol || "UNKNOWN",
+        decimals: decimals || 18
+      };
+    } catch (error) {
+      throw new Error(`Failed to get token metadata: ${error}`);
+    }
+  }
+  async detectTokensFromEvents(address) {
+    try {
+      const currentBlock = await this.provider.getBlockNumber();
+      const fromBlock = Math.max(0, currentBlock - 1e4);
+      const filter = {
+        fromBlock,
+        toBlock: currentBlock,
+        topics: [
+          ethers.id("Transfer(address,address,uint256)"),
+          null,
+          // from address (any)
+          ethers.zeroPadValue(address, 32)
+          // to address (our target)
+        ]
+      };
+      const logs = await this.provider.getLogs(filter);
+      const tokenAddresses = /* @__PURE__ */ new Set();
+      for (const log of logs) {
+        tokenAddresses.add(log.address);
+      }
+      return Array.from(tokenAddresses);
+    } catch (error) {
+      console.warn(`Failed to detect tokens from events: ${error}`);
+      return [];
+    }
+  }
+  // Additional utility methods for enhanced token support
+  async getTokenInfo(tokenAddress) {
+    try {
+      return await this.getTokenMetadata(tokenAddress);
+    } catch (error) {
+      console.warn(`Failed to get token info for ${tokenAddress}: ${error}`);
+      return null;
+    }
+  }
+  async getTokenBalanceForAddress(address, tokenAddress) {
+    try {
+      return await this.getTokenBalance(address, tokenAddress);
+    } catch (error) {
+      throw new Error(`Failed to get token balance for ${tokenAddress}: ${error}`);
+    }
+  }
+  async getMultipleTokenBalances(address, tokenAddresses) {
+    const balances = /* @__PURE__ */ new Map();
+    await Promise.all(
+      tokenAddresses.map(async (tokenAddress) => {
+        try {
+          const balance = await this.getTokenBalance(address, tokenAddress);
+          balances.set(tokenAddress, balance);
+        } catch (error) {
+          console.warn(`Failed to get balance for token ${tokenAddress}: ${error}`);
+          balances.set(tokenAddress, 0n);
+        }
+      })
+    );
+    return balances;
+  }
+};
+
+// src/WarpEvmExecutor.ts
+import {
+  applyResultsToMessages,
+  getNextInfo,
+  getWarpActionByIndex
+} from "@vleap/warps";
+import { ethers as ethers3 } from "ethers";
+
+// src/constants.ts
+var WarpEvmConstants = {
+  GasLimit: {
+    Default: 21e3,
+    ContractCall: 1e5,
+    ContractDeploy: 5e5,
+    Transfer: 21e3,
+    Approve: 46e3,
+    Swap: 2e5
+  },
+  GasPrice: {
+    Default: "20000000000"
+  },
+  Validation: {
+    MinGasLimit: 21e3,
+    MaxGasLimit: 3e7
+  }
+};
+var EthereumExplorers = /* @__PURE__ */ ((EthereumExplorers2) => {
+  EthereumExplorers2["Etherscan"] = "etherscan";
+  EthereumExplorers2["EtherscanSepolia"] = "etherscan_sepolia";
+  EthereumExplorers2["Ethplorer"] = "ethplorer";
+  EthereumExplorers2["Blockscout"] = "blockscout";
+  EthereumExplorers2["BlockscoutSepolia"] = "blockscout_sepolia";
+  return EthereumExplorers2;
+})(EthereumExplorers || {});
+var ArbitrumExplorers = /* @__PURE__ */ ((ArbitrumExplorers2) => {
+  ArbitrumExplorers2["Arbiscan"] = "arbiscan";
+  ArbitrumExplorers2["ArbiscanSepolia"] = "arbiscan_sepolia";
+  ArbitrumExplorers2["BlockscoutArbitrum"] = "blockscout_arbitrum";
+  ArbitrumExplorers2["BlockscoutArbitrumSepolia"] = "blockscout_arbitrum_sepolia";
+  return ArbitrumExplorers2;
+})(ArbitrumExplorers || {});
+var BaseExplorers = /* @__PURE__ */ ((BaseExplorers2) => {
+  BaseExplorers2["Basescan"] = "basescan";
+  BaseExplorers2["BasescanSepolia"] = "basescan_sepolia";
+  BaseExplorers2["BlockscoutBase"] = "blockscout_base";
+  BaseExplorers2["BlockscoutBaseSepolia"] = "blockscout_base_sepolia";
+  return BaseExplorers2;
+})(BaseExplorers || {});
+var EvmExplorers = {
+  ethereum: {
+    mainnet: ["etherscan" /* Etherscan */, "ethplorer" /* Ethplorer */, "blockscout" /* Blockscout */],
+    testnet: ["etherscan_sepolia" /* EtherscanSepolia */, "blockscout_sepolia" /* BlockscoutSepolia */],
+    devnet: ["etherscan_sepolia" /* EtherscanSepolia */, "blockscout_sepolia" /* BlockscoutSepolia */]
+  },
+  arbitrum: {
+    mainnet: ["arbiscan" /* Arbiscan */, "blockscout_arbitrum" /* BlockscoutArbitrum */],
+    testnet: ["arbiscan_sepolia" /* ArbiscanSepolia */, "blockscout_arbitrum_sepolia" /* BlockscoutArbitrumSepolia */],
+    devnet: ["arbiscan_sepolia" /* ArbiscanSepolia */, "blockscout_arbitrum_sepolia" /* BlockscoutArbitrumSepolia */]
+  },
+  base: {
+    mainnet: ["basescan" /* Basescan */, "blockscout_base" /* BlockscoutBase */],
+    testnet: ["basescan_sepolia" /* BasescanSepolia */, "blockscout_base_sepolia" /* BlockscoutBaseSepolia */],
+    devnet: ["basescan_sepolia" /* BasescanSepolia */, "blockscout_base_sepolia" /* BlockscoutBaseSepolia */]
+  }
+};
+var ExplorerUrls = {
+  ["etherscan" /* Etherscan */]: "https://etherscan.io",
+  ["etherscan_sepolia" /* EtherscanSepolia */]: "https://sepolia.etherscan.io",
+  ["ethplorer" /* Ethplorer */]: "https://ethplorer.io",
+  ["blockscout" /* Blockscout */]: "https://eth.blockscout.com",
+  ["blockscout_sepolia" /* BlockscoutSepolia */]: "https://sepolia.blockscout.com",
+  ["arbiscan" /* Arbiscan */]: "https://arbiscan.io",
+  ["arbiscan_sepolia" /* ArbiscanSepolia */]: "https://sepolia.arbiscan.io",
+  ["blockscout_arbitrum" /* BlockscoutArbitrum */]: "https://arbitrum.blockscout.com",
+  ["blockscout_arbitrum_sepolia" /* BlockscoutArbitrumSepolia */]: "https://sepolia.blockscout.com",
+  ["basescan" /* Basescan */]: "https://basescan.org",
+  ["basescan_sepolia" /* BasescanSepolia */]: "https://sepolia.basescan.org",
+  ["blockscout_base" /* BlockscoutBase */]: "https://base.blockscout.com",
+  ["blockscout_base_sepolia" /* BlockscoutBaseSepolia */]: "https://sepolia.blockscout.com"
+};
+
+// src/WarpEvmResults.ts
+import {
+  evaluateResultsCommon,
+  parseResultsOutIndex,
+  WarpConstants as WarpConstants2
+} from "@vleap/warps";
+
+// src/WarpEvmSerializer.ts
+import {
+  WarpConstants,
+  WarpSerializer
+} from "@vleap/warps";
+import { ethers as ethers2 } from "ethers";
+var SplitParamsRegex = new RegExp(`${WarpConstants.ArgParamsSeparator}(.*)`);
+var WarpEvmSerializer = class {
+  constructor() {
+    this.coreSerializer = new WarpSerializer();
+  }
+  typedToString(value) {
+    if (typeof value === "string") {
+      if (ethers2.isAddress(value)) {
+        return `address:${value}`;
+      }
+      if (ethers2.isHexString(value) && !ethers2.isAddress(value)) {
+        return `hex:${value}`;
+      }
+      return `string:${value}`;
+    }
+    if (typeof value === "number") {
+      if (Number.isInteger(value)) {
+        if (value >= 0 && value <= 255) return `uint8:${value}`;
+        if (value >= 0 && value <= 65535) return `uint16:${value}`;
+        if (value >= 0 && value <= 4294967295) return `uint32:${value}`;
+        return `uint64:${value}`;
+      }
+      return `string:${value}`;
+    }
+    if (typeof value === "bigint") {
+      return `biguint:${value.toString()}`;
+    }
+    if (typeof value === "boolean") {
+      return `boolean:${value}`;
+    }
+    if (Array.isArray(value)) {
+      if (value.length === 0) return `list:string:`;
+      const types = value.map((item) => this.typedToString(item).split(WarpConstants.ArgParamsSeparator)[0]);
+      const type = types[0];
+      const values = value.map((item) => this.typedToString(item).split(WarpConstants.ArgParamsSeparator)[1]);
+      return `list:${type}:${values.join(",")}`;
+    }
+    if (value === null || value === void 0) {
+      return `string:null`;
+    }
+    return `string:${String(value)}`;
+  }
+  typedToNative(value) {
+    const stringValue = this.typedToString(value);
+    const [type, ...valueParts] = stringValue.split(WarpConstants.ArgParamsSeparator);
+    const nativeValue = valueParts.join(WarpConstants.ArgParamsSeparator);
+    return [type, this.parseNativeValue(type, nativeValue)];
+  }
+  nativeToTyped(type, value) {
+    switch (type) {
+      case "string":
+        return String(value);
+      case "uint8":
+      case "uint16":
+      case "uint32":
+      case "uint64":
+        return BigInt(value);
+      case "biguint":
+        return BigInt(value);
+      case "boolean":
+        return Boolean(value);
+      case "address":
+        return String(value);
+      case "hex":
+        return String(value);
+      default:
+        if (type.startsWith("list:")) {
+          const [, itemType, itemsStr] = type.split(":");
+          if (!itemsStr) return [];
+          const items = itemsStr.split(",");
+          return items.map((item) => this.nativeToTyped(itemType, item));
+        }
+        return String(value);
+    }
+  }
+  nativeToType(type) {
+    switch (type) {
+      case "string":
+        return "string";
+      case "uint8":
+      case "uint16":
+      case "uint32":
+      case "uint64":
+      case "biguint":
+        return "bigint";
+      case "boolean":
+        return "boolean";
+      case "address":
+        return "string";
+      case "hex":
+        return "string";
+      default:
+        return "string";
+    }
+  }
+  stringToTyped(value) {
+    const parts = value.split(WarpConstants.ArgParamsSeparator, 2);
+    if (parts.length < 2) {
+      return value;
+    }
+    const [type, stringValue] = parts;
+    switch (type) {
+      case "string":
+        return stringValue;
+      case "uint8":
+      case "uint16":
+      case "uint32":
+      case "uint64":
+        return BigInt(stringValue);
+      case "biguint":
+        return BigInt(stringValue);
+      case "boolean":
+        return stringValue === "true";
+      case "address":
+        return stringValue;
+      case "hex":
+        return stringValue;
+      default:
+        if (type.startsWith("list:")) {
+          const [, itemType, itemsStr] = type.split(":");
+          if (!itemsStr) return [];
+          const items = itemsStr.split(",");
+          return items.map((item) => this.stringToTyped(`${itemType}:${item}`));
+        }
+        return stringValue;
+    }
+  }
+  parseNativeValue(type, value) {
+    switch (type) {
+      case "string":
+        return value;
+      case "uint8":
+      case "uint16":
+      case "uint32":
+      case "uint64":
+      case "biguint":
+        return BigInt(value);
+      case "boolean":
+        return value === "true";
+      case "address":
+        return value;
+      case "hex":
+        return value;
+      default:
+        return value;
+    }
+  }
+};
+
+// src/WarpEvmResults.ts
+var WarpEvmResults = class {
+  constructor(config) {
+    this.config = config;
+    this.serializer = new WarpEvmSerializer();
+  }
+  async getTransactionExecutionResults(warp, tx) {
+    const success = tx.status === 1;
+    const gasUsed = tx.gasUsed?.toString() || "0";
+    const gasPrice = tx.gasPrice?.toString() || "0";
+    const blockNumber = tx.blockNumber?.toString() || "0";
+    const transactionHash = tx.hash;
+    const logs = tx.logs.map((log) => ({
+      address: log.address,
+      topics: log.topics,
+      data: log.data,
+      blockNumber: log.blockNumber?.toString() || "0",
+      transactionHash: log.transactionHash,
+      index: log.index?.toString() || "0"
+    }));
+    return {
+      success,
+      warp,
+      action: 0,
+      user: this.config.user?.wallets?.evm || null,
+      txHash: transactionHash,
+      next: null,
+      values: [transactionHash, blockNumber, gasUsed, gasPrice, ...logs.length > 0 ? logs : []],
+      results: {},
+      messages: {}
+    };
+  }
+  async extractQueryResults(warp, typedValues, actionIndex, inputs) {
+    const values = typedValues.map((t) => this.serializer.typedToString(t));
+    const valuesRaw = typedValues.map((t) => this.serializer.typedToNative(t)[1]);
+    let results = {};
+    if (!warp.results) return { values, results };
+    const getNestedValue = (path) => {
+      const indices = path.split(".").slice(1).map((i) => parseInt(i) - 1);
+      if (indices.length === 0) return void 0;
+      let value = valuesRaw[indices[0]];
+      for (let i = 1; i < indices.length; i++) {
+        if (value === void 0 || value === null) return void 0;
+        value = value[indices[i]];
+      }
+      return value;
+    };
+    for (const [key, path] of Object.entries(warp.results)) {
+      if (path.startsWith(WarpConstants2.Transform.Prefix)) continue;
+      const currentActionIndex = parseResultsOutIndex(path);
+      if (currentActionIndex !== null && currentActionIndex !== actionIndex) {
+        results[key] = null;
+        continue;
+      }
+      if (path.startsWith("out.") || path === "out" || path.startsWith("out[")) {
+        results[key] = getNestedValue(path) || null;
+      } else {
+        results[key] = path;
+      }
+    }
+    return { values, results: await evaluateResultsCommon(warp, results, actionIndex, inputs) };
+  }
+};
+
+// src/WarpEvmExecutor.ts
+var WarpEvmExecutor = class {
+  constructor(config) {
+    this.config = config;
+    this.serializer = new WarpEvmSerializer();
+    this.provider = new ethers3.JsonRpcProvider(getEvmApiUrl(config.env));
+    this.results = new WarpEvmResults(config);
+  }
+  async createTransaction(executable) {
+    const action = getWarpActionByIndex(executable.warp, executable.action);
+    let tx = null;
+    if (action.type === "transfer") {
+      tx = await this.createTransferTransaction(executable);
+    } else if (action.type === "contract") {
+      tx = await this.createContractCallTransaction(executable);
+    } else if (action.type === "query") {
+      throw new Error("WarpEvmExecutor: Invalid action type for createTransaction; Use executeQuery instead");
+    } else if (action.type === "collect") {
+      throw new Error("WarpEvmExecutor: Invalid action type for createTransaction; Use executeCollect instead");
+    }
+    if (!tx) throw new Error(`WarpEvmExecutor: Invalid action type (${action.type})`);
+    return tx;
+  }
+  async createTransferTransaction(executable) {
+    const userWallet = this.config.user?.wallets?.[executable.chain.name];
+    if (!userWallet) throw new Error("WarpEvmExecutor: createTransfer - user address not set");
+    if (!ethers3.isAddress(executable.destination)) {
+      throw new Error(`WarpEvmExecutor: Invalid destination address: ${executable.destination}`);
+    }
+    if (executable.value < 0) {
+      throw new Error(`WarpEvmExecutor: Transfer value cannot be negative: ${executable.value}`);
+    }
+    const tx = {
+      to: executable.destination,
+      value: executable.value,
+      data: executable.data ? this.serializer.stringToTyped(executable.data) : "0x"
+    };
+    return this.estimateGasAndSetDefaults(tx, userWallet);
+  }
+  async createContractCallTransaction(executable) {
+    const userWallet = this.config.user?.wallets?.[executable.chain.name];
+    if (!userWallet) throw new Error("WarpEvmExecutor: createContractCall - user address not set");
+    const action = getWarpActionByIndex(executable.warp, executable.action);
+    if (!action || !("func" in action) || !action.func) {
+      throw new Error("WarpEvmExecutor: Contract action must have a function name");
+    }
+    if (!ethers3.isAddress(executable.destination)) {
+      throw new Error(`WarpEvmExecutor: Invalid contract address: ${executable.destination}`);
+    }
+    if (executable.value < 0) {
+      throw new Error(`WarpEvmExecutor: Contract call value cannot be negative: ${executable.value}`);
+    }
+    try {
+      const iface = new ethers3.Interface([`function ${action.func}`]);
+      const encodedData = iface.encodeFunctionData(action.func, executable.args);
+      const tx = {
+        to: executable.destination,
+        value: executable.value,
+        data: encodedData
+      };
+      return this.estimateGasAndSetDefaults(tx, userWallet);
+    } catch (error) {
+      throw new Error(`WarpEvmExecutor: Failed to encode function data for ${action.func}: ${error}`);
+    }
+  }
+  async executeQuery(executable) {
+    const action = getWarpActionByIndex(executable.warp, executable.action);
+    if (action.type !== "query") {
+      throw new Error(`WarpEvmExecutor: Invalid action type for executeQuery: ${action.type}`);
+    }
+    if (!action.func) {
+      throw new Error("WarpEvmExecutor: Query action must have a function name");
+    }
+    if (!ethers3.isAddress(executable.destination)) {
+      throw new Error(`WarpEvmExecutor: Invalid contract address for query: ${executable.destination}`);
+    }
+    try {
+      const iface = new ethers3.Interface([`function ${action.func}`]);
+      const encodedData = iface.encodeFunctionData(action.func, executable.args);
+      const result = await this.provider.call({
+        to: executable.destination,
+        data: encodedData
+      });
+      const decodedResult = iface.decodeFunctionResult(action.func, result);
+      const isSuccess = true;
+      const { values, results } = await this.results.extractQueryResults(
+        executable.warp,
+        decodedResult,
+        executable.action,
+        executable.resolvedInputs
+      );
+      const next = getNextInfo(this.config, [], executable.warp, executable.action, results);
+      return {
+        success: isSuccess,
+        warp: executable.warp,
+        action: executable.action,
+        user: this.config.user?.wallets?.[executable.chain.name] || null,
+        txHash: null,
+        next,
+        values,
+        results,
+        messages: applyResultsToMessages(executable.warp, results)
+      };
+    } catch (error) {
+      return {
+        success: false,
+        warp: executable.warp,
+        action: executable.action,
+        user: this.config.user?.wallets?.[executable.chain.name] || null,
+        txHash: null,
+        next: null,
+        values: [],
+        results: {},
+        messages: {}
+      };
+    }
+  }
+  async preprocessInput(chain, input, type, value) {
+    const typedValue = this.serializer.stringToTyped(value);
+    switch (type) {
+      case "address":
+        if (!ethers3.isAddress(typedValue)) {
+          throw new Error(`Invalid address format: ${typedValue}`);
+        }
+        return ethers3.getAddress(typedValue);
+      case "hex":
+        if (!ethers3.isHexString(typedValue)) {
+          throw new Error(`Invalid hex format: ${typedValue}`);
+        }
+        return typedValue;
+      case "uint8":
+      case "uint16":
+      case "uint32":
+      case "uint64":
+      case "biguint":
+        const bigIntValue = BigInt(typedValue);
+        if (bigIntValue < 0) {
+          throw new Error(`Negative value not allowed for type ${type}: ${typedValue}`);
+        }
+        return bigIntValue.toString();
+      default:
+        return String(typedValue);
+    }
+  }
+  async estimateGasAndSetDefaults(tx, from) {
+    try {
+      const gasEstimate = await this.provider.estimateGas({
+        ...tx,
+        from
+      });
+      if (gasEstimate < BigInt(WarpEvmConstants.Validation.MinGasLimit)) {
+        throw new Error(`Gas estimate too low: ${gasEstimate}`);
+      }
+      if (gasEstimate > BigInt(WarpEvmConstants.Validation.MaxGasLimit)) {
+        throw new Error(`Gas estimate too high: ${gasEstimate}`);
+      }
+      const feeData = await this.provider.getFeeData();
+      if (feeData.maxFeePerGas && feeData.maxPriorityFeePerGas) {
+        return {
+          ...tx,
+          gasLimit: gasEstimate,
+          maxFeePerGas: feeData.maxFeePerGas,
+          maxPriorityFeePerGas: feeData.maxPriorityFeePerGas
+        };
+      } else if (feeData.gasPrice) {
+        return {
+          ...tx,
+          gasLimit: gasEstimate,
+          gasPrice: feeData.gasPrice
+        };
+      } else {
+        return {
+          ...tx,
+          gasLimit: gasEstimate,
+          gasPrice: ethers3.parseUnits(WarpEvmConstants.GasPrice.Default, "wei")
+        };
+      }
+    } catch (error) {
+      let defaultGasLimit = BigInt(WarpEvmConstants.GasLimit.Default);
+      if (tx.data && tx.data !== "0x") {
+        defaultGasLimit = BigInt(WarpEvmConstants.GasLimit.ContractCall);
+      } else {
+        defaultGasLimit = BigInt(WarpEvmConstants.GasLimit.Transfer);
+      }
+      return {
+        ...tx,
+        gasLimit: defaultGasLimit,
+        gasPrice: ethers3.parseUnits(WarpEvmConstants.GasPrice.Default, "wei")
+      };
+    }
+  }
+  async signMessage(message, privateKey) {
+    throw new Error("Not implemented");
+  }
+};
+
+// src/WarpEvmExplorer.ts
+var WarpEvmExplorer = class {
+  constructor(chain, config) {
+    this.chain = chain;
+    this.config = config;
+  }
+  getExplorers() {
+    const chainExplorers = EvmExplorers[this.chain.name];
+    if (!chainExplorers) {
+      return ["Default"];
+    }
+    const explorers = chainExplorers[this.config.env];
+    if (!explorers) {
+      return ["Default"];
+    }
+    return explorers;
+  }
+  getPrimaryExplorer() {
+    const explorers = this.getExplorers();
+    return explorers[0];
+  }
+  getExplorerUrlByName(explorer) {
+    const userPreference = this.config.preferences?.explorers?.[this.chain.name];
+    if (userPreference && !explorer) {
+      const url2 = ExplorerUrls[userPreference];
+      if (url2) return url2;
+    }
+    if (explorer) {
+      const url2 = ExplorerUrls[explorer];
+      if (url2) return url2;
+    }
+    const primaryExplorer = this.getPrimaryExplorer();
+    const url = ExplorerUrls[primaryExplorer];
+    return url || ExplorerUrls[primaryExplorer];
+  }
+  getAccountUrl(address, explorer) {
+    const baseUrl = this.getExplorerUrlByName(explorer);
+    return `${baseUrl}/address/${address}`;
+  }
+  getTransactionUrl(hash, explorer) {
+    const baseUrl = this.getExplorerUrlByName(explorer);
+    return `${baseUrl}/tx/${hash}`;
+  }
+  getBlockUrl(blockNumber, explorer) {
+    const baseUrl = this.getExplorerUrlByName(explorer);
+    return `${baseUrl}/block/${blockNumber}`;
+  }
+  getAssetUrl(identifier, explorer) {
+    const baseUrl = this.getExplorerUrlByName(explorer);
+    return `${baseUrl}/token/${identifier}`;
+  }
+  getContractUrl(address, explorer) {
+    const baseUrl = this.getExplorerUrlByName(explorer);
+    return `${baseUrl}/address/${address}`;
+  }
+  getAllExplorers() {
+    return this.getExplorers();
+  }
+  getExplorerByName(name) {
+    const explorers = this.getExplorers();
+    return explorers.find((explorer) => explorer.toLowerCase() === name.toLowerCase());
+  }
+  getAccountUrls(address) {
+    const explorers = this.getAllExplorers();
+    const urls = {};
+    explorers.forEach((explorer) => {
+      const url = ExplorerUrls[explorer];
+      if (url) {
+        urls[explorer] = `${url}/address/${address}`;
+      }
+    });
+    return urls;
+  }
+  getTransactionUrls(hash) {
+    const explorers = this.getAllExplorers();
+    const urls = {};
+    explorers.forEach((explorer) => {
+      const url = ExplorerUrls[explorer];
+      if (url) {
+        urls[explorer] = `${url}/tx/${hash}`;
+      }
+    });
+    return urls;
+  }
+};
+
+// src/chains/common.ts
+var createEvmAdapter = (chainName, chainPrefix, chainInfos) => {
+  return (config, fallback) => {
+    if (!fallback) throw new Error(`${chainName} adapter requires a fallback adapter`);
+    return {
+      chain: chainName,
+      chainInfo: chainInfos[config.env],
+      prefix: chainPrefix,
+      builder: () => fallback.builder(),
+      executor: new WarpEvmExecutor(config),
+      results: new WarpEvmResults(config),
+      serializer: new WarpEvmSerializer(),
+      registry: fallback.registry,
+      explorer: new WarpEvmExplorer(chainInfos[config.env], config),
+      abiBuilder: () => fallback.abiBuilder(),
+      brandBuilder: () => fallback.brandBuilder(),
+      dataLoader: new WarpEvmDataLoader(config, chainInfos[config.env])
+    };
+  };
+};
+
+// src/chains/arbitrum.ts
+var ChainNameArbitrum = "arbitrum";
+var getArbitrumAdapter = createEvmAdapter(ChainNameArbitrum, "arb", {
+  devnet: {
+    name: ChainNameArbitrum,
+    displayName: "Arbitrum Devnet",
+    chainId: "421614",
+    blockTime: 1e3,
+    addressHrp: "0x",
+    apiUrl: "https://sepolia-rollup.arbitrum.io/rpc",
+    nativeToken: "ETH"
+  },
+  testnet: {
+    name: ChainNameArbitrum,
+    displayName: "Arbitrum Testnet",
+    chainId: "421613",
+    blockTime: 1e3,
+    addressHrp: "0x",
+    apiUrl: "https://goerli-rollup.arbitrum.io/rpc",
+    nativeToken: "ETH"
+  },
+  mainnet: {
+    name: ChainNameArbitrum,
+    displayName: "Arbitrum",
+    chainId: "42161",
+    blockTime: 1e3,
+    addressHrp: "0x",
+    apiUrl: "https://arb1.arbitrum.io/rpc",
+    nativeToken: "ETH"
+  }
+});
+
+// src/chains/base.ts
+var ChainNameBase = "base";
+var getBaseAdapter = createEvmAdapter(ChainNameBase, "base", {
+  mainnet: {
+    name: ChainNameBase,
+    displayName: "Base",
+    chainId: "8453",
+    blockTime: 2e3,
+    addressHrp: "0x",
+    apiUrl: "https://mainnet.base.org",
+    nativeToken: "ETH"
+  },
+  testnet: {
+    name: ChainNameBase,
+    displayName: "Base Testnet",
+    chainId: "84531",
+    blockTime: 2e3,
+    addressHrp: "0x",
+    apiUrl: "https://goerli.base.org",
+    nativeToken: "ETH"
+  },
+  devnet: {
+    name: ChainNameBase,
+    displayName: "Base Devnet",
+    chainId: "84532",
+    blockTime: 2e3,
+    addressHrp: "0x",
+    apiUrl: "https://sepolia.base.org",
+    nativeToken: "ETH"
+  }
+});
+
+// src/chains/ethereum.ts
+var ChainNameEthereum = "ethereum";
+var getEthereumAdapter = createEvmAdapter(ChainNameEthereum, "eth", {
+  devnet: {
+    name: ChainNameEthereum,
+    displayName: "Ethereum Devnet",
+    chainId: "11155111",
+    blockTime: 12e3,
+    addressHrp: "0x",
+    apiUrl: "https://eth-sepolia.g.alchemy.com/v2/YOUR_API_KEY",
+    nativeToken: "ETH"
+  },
+  testnet: {
+    name: ChainNameEthereum,
+    displayName: "Ethereum Testnet",
+    chainId: "5",
+    blockTime: 12e3,
+    addressHrp: "0x",
+    apiUrl: "https://eth-goerli.g.alchemy.com/v2/YOUR_API_KEY",
+    nativeToken: "ETH"
+  },
+  mainnet: {
+    name: ChainNameEthereum,
+    displayName: "Ethereum Mainnet",
+    chainId: "1",
+    blockTime: 12e3,
+    addressHrp: "0x",
+    apiUrl: "https://eth-mainnet.g.alchemy.com/v2/YOUR_API_KEY",
+    nativeToken: "ETH"
+  }
+});
+
+// src/chains/combined.ts
+var getAllEvmAdapters = (config, fallback) => [
+  getEthereumAdapter(config, fallback),
+  getArbitrumAdapter(config, fallback),
+  getBaseAdapter(config, fallback)
+];
+var getAllEvmChainNames = () => [ChainNameArbitrum, ChainNameBase, ChainNameEthereum];
+export {
+  ArbitrumExplorers,
+  BaseExplorers,
+  ChainNameArbitrum,
+  ChainNameBase,
+  ChainNameEthereum,
+  EVM_CHAIN_CONFIGS,
+  EthereumExplorers,
+  EvmExplorers,
+  ExplorerUrls,
+  WarpEvmConstants,
+  WarpEvmExecutor,
+  WarpEvmExplorer,
+  WarpEvmResults,
+  WarpEvmSerializer,
+  getAllEvmAdapters,
+  getAllEvmChainNames,
+  getArbitrumAdapter,
+  getBaseAdapter,
+  getEthereumAdapter,
+  getEvmApiUrl,
+  getEvmChainConfig,
+  getEvmExplorerUrl
+};
+//# sourceMappingURL=index.mjs.map