@joai/warps-adapter-evm 1.0.0-beta.74

package/dist/index.mjs

@@ -0,0 +1,2301 @@
+// src/chains/arbitrum.ts
+import { WarpChainName as WarpChainName10 } from "@joai/warps";
+
+// src/WarpEvmDataLoader.ts
+import {
+  CacheTtl as CacheTtl2,
+  getProviderConfig,
+  getWarpChainAssetLogoUrl,
+  WarpCache as WarpCache2,
+  WarpCacheKey
+} from "@joai/warps";
+import { ethers as ethers3 } from "ethers";
+
+// src/providers/UniswapService.ts
+import { CacheTtl } from "@joai/warps";
+var _UniswapService = class _UniswapService {
+  constructor(cache, chainId) {
+    this.cache = cache;
+    this.chainId = chainId;
+  }
+  async getTokenList() {
+    try {
+      const response = await fetch(_UniswapService.UNISWAP_TOKEN_LIST_URL);
+      if (!response.ok) {
+        throw new Error(`Failed to fetch Uniswap token list: ${response.status}`);
+      }
+      const tokenList = await response.json();
+      return tokenList;
+    } catch (error) {
+      throw new Error(`Failed to fetch Uniswap token list: ${error}`);
+    }
+  }
+  async findToken(address) {
+    const normalizedAddress = address.toLowerCase();
+    const cacheKey = `uniswap:token:${this.chainId}:${normalizedAddress}`;
+    const cachedToken = this.cache.get(cacheKey);
+    if (cachedToken) {
+      return cachedToken;
+    }
+    try {
+      const tokenList = await this.getTokenList();
+      const token = tokenList.tokens.find((token2) => token2.address.toLowerCase() === normalizedAddress) || null;
+      if (token && token.chainId !== this.chainId) {
+        return null;
+      }
+      if (token) {
+        this.cache.set(cacheKey, token, CacheTtl.OneHour);
+      } else {
+        this.cache.set(cacheKey, null, CacheTtl.OneMinute * 5);
+      }
+      return token;
+    } catch (error) {
+      return null;
+    }
+  }
+  async getTokenMetadata(address) {
+    const normalizedAddress = address.toLowerCase();
+    const cacheKey = `uniswap:metadata:${this.chainId}:${normalizedAddress}`;
+    const cachedMetadata = this.cache.get(cacheKey);
+    if (cachedMetadata !== null) {
+      return cachedMetadata;
+    }
+    const token = await this.findToken(address);
+    if (!token) {
+      this.cache.set(cacheKey, null, CacheTtl.OneMinute * 5);
+      return null;
+    }
+    const metadata = {
+      name: token.name,
+      symbol: token.symbol,
+      decimals: token.decimals,
+      logoUrl: token.logoURI
+    };
+    this.cache.set(cacheKey, metadata, CacheTtl.OneHour);
+    return metadata;
+  }
+  async getBridgeInfo(address) {
+    const normalizedAddress = address.toLowerCase();
+    const cacheKey = `uniswap:bridge:${this.chainId}:${normalizedAddress}`;
+    const cachedBridgeInfo = this.cache.get(cacheKey);
+    if (cachedBridgeInfo !== null) {
+      return cachedBridgeInfo;
+    }
+    const token = await this.findToken(address);
+    if (!token?.extensions?.bridgeInfo) {
+      this.cache.set(cacheKey, null, CacheTtl.OneMinute * 5);
+      return null;
+    }
+    const bridgeInfo = {};
+    for (const [chainId, info] of Object.entries(token.extensions.bridgeInfo)) {
+      bridgeInfo[chainId] = info.tokenAddress;
+    }
+    this.cache.set(cacheKey, bridgeInfo, CacheTtl.OneHour);
+    return bridgeInfo;
+  }
+};
+_UniswapService.UNISWAP_TOKEN_LIST_URL = "https://tokens.uniswap.org";
+var UniswapService = _UniswapService;
+
+// src/providers/PrivateKeyWalletProvider.ts
+import { ethers } from "ethers";
+import {
+  getWarpWalletMnemonicFromConfig,
+  getWarpWalletPrivateKeyFromConfig,
+  setWarpWalletInConfig
+} from "@joai/warps";
+var _PrivateKeyWalletProvider = class _PrivateKeyWalletProvider {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    this.wallet = null;
+  }
+  async getAddress() {
+    try {
+      const wallet = this.getWallet();
+      return wallet.address;
+    } catch {
+      return null;
+    }
+  }
+  async getPublicKey() {
+    try {
+      const wallet = this.getWallet();
+      const publicKey = wallet.signingKey.publicKey;
+      return publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey;
+    } catch {
+      return null;
+    }
+  }
+  async signTransaction(tx) {
+    const wallet = this.getWallet();
+    const txRequest = {
+      to: tx.to,
+      data: tx.data,
+      value: tx.value || 0,
+      gasLimit: tx.gasLimit,
+      maxFeePerGas: tx.maxFeePerGas,
+      maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
+      nonce: tx.nonce,
+      chainId: tx.chainId
+    };
+    const signedTx = await wallet.signTransaction(txRequest);
+    return { ...tx, signature: signedTx };
+  }
+  async signMessage(message) {
+    const wallet = this.getWallet();
+    return await wallet.signMessage(message);
+  }
+  getWalletInstance() {
+    return this.getWallet();
+  }
+  async importFromMnemonic(mnemonic) {
+    const wallet = ethers.Wallet.fromPhrase(mnemonic);
+    const walletDetails = {
+      provider: _PrivateKeyWalletProvider.PROVIDER_NAME,
+      address: wallet.address,
+      privateKey: wallet.privateKey,
+      mnemonic
+    };
+    setWarpWalletInConfig(this.config, this.chain.name, walletDetails);
+    return walletDetails;
+  }
+  async importFromPrivateKey(privateKey) {
+    const wallet = new ethers.Wallet(privateKey);
+    const walletDetails = {
+      provider: _PrivateKeyWalletProvider.PROVIDER_NAME,
+      address: wallet.address,
+      privateKey: wallet.privateKey,
+      mnemonic: null
+    };
+    setWarpWalletInConfig(this.config, this.chain.name, walletDetails);
+    return walletDetails;
+  }
+  async export() {
+    const wallet = this.getWallet();
+    const mnemonic = getWarpWalletMnemonicFromConfig(this.config, this.chain.name);
+    return {
+      provider: _PrivateKeyWalletProvider.PROVIDER_NAME,
+      address: wallet.address,
+      privateKey: wallet.privateKey,
+      mnemonic: mnemonic || null
+    };
+  }
+  async generate() {
+    const wallet = ethers.Wallet.createRandom();
+    return {
+      provider: _PrivateKeyWalletProvider.PROVIDER_NAME,
+      address: wallet.address,
+      privateKey: wallet.privateKey,
+      mnemonic: null
+    };
+  }
+  getWallet() {
+    if (this.wallet) return this.wallet;
+    const privateKey = getWarpWalletPrivateKeyFromConfig(this.config, this.chain.name);
+    if (!privateKey) throw new Error("No private key provided");
+    this.wallet = new ethers.Wallet(privateKey);
+    return this.wallet;
+  }
+};
+_PrivateKeyWalletProvider.PROVIDER_NAME = "privateKey";
+var PrivateKeyWalletProvider = _PrivateKeyWalletProvider;
+
+// src/providers/MnemonicWalletProvider.ts
+import { ethers as ethers2, HDNodeWallet } from "ethers";
+import * as bip39 from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english.js";
+import {
+  getWarpWalletMnemonicFromConfig as getWarpWalletMnemonicFromConfig2,
+  getWarpWalletPrivateKeyFromConfig as getWarpWalletPrivateKeyFromConfig2,
+  normalizeAndValidateMnemonic,
+  normalizeMnemonic,
+  setWarpWalletInConfig as setWarpWalletInConfig2,
+  validateMnemonicLength
+} from "@joai/warps";
+var _MnemonicWalletProvider = class _MnemonicWalletProvider {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    this.wallet = null;
+  }
+  async getAddress() {
+    try {
+      const wallet = this.getWallet();
+      return wallet.address;
+    } catch {
+      return null;
+    }
+  }
+  async getPublicKey() {
+    try {
+      const wallet = this.getWallet();
+      const publicKey = wallet.signingKey.publicKey;
+      return publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey;
+    } catch {
+      return null;
+    }
+  }
+  async signTransaction(tx) {
+    const wallet = this.getWallet();
+    const txRequest = {
+      to: tx.to,
+      data: tx.data,
+      value: tx.value || 0,
+      gasLimit: tx.gasLimit,
+      maxFeePerGas: tx.maxFeePerGas,
+      maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
+      nonce: tx.nonce,
+      chainId: tx.chainId
+    };
+    const signedTx = await wallet.signTransaction(txRequest);
+    return { ...tx, signature: signedTx };
+  }
+  async signMessage(message) {
+    const wallet = this.getWallet();
+    return await wallet.signMessage(message);
+  }
+  getWalletInstance() {
+    return this.getWallet();
+  }
+  async importFromMnemonic(mnemonic) {
+    const trimmedMnemonic = normalizeAndValidateMnemonic(mnemonic);
+    const wallet = HDNodeWallet.fromPhrase(trimmedMnemonic);
+    const walletDetails = {
+      provider: _MnemonicWalletProvider.PROVIDER_NAME,
+      address: wallet.address,
+      privateKey: wallet.privateKey,
+      mnemonic: trimmedMnemonic
+    };
+    setWarpWalletInConfig2(this.config, this.chain.name, walletDetails);
+    return walletDetails;
+  }
+  async importFromPrivateKey(privateKey) {
+    const wallet = new ethers2.Wallet(privateKey);
+    const walletDetails = {
+      provider: _MnemonicWalletProvider.PROVIDER_NAME,
+      address: wallet.address,
+      privateKey: wallet.privateKey,
+      mnemonic: null
+    };
+    setWarpWalletInConfig2(this.config, this.chain.name, walletDetails);
+    return walletDetails;
+  }
+  async export() {
+    const wallet = this.getWallet();
+    const mnemonic = getWarpWalletMnemonicFromConfig2(this.config, this.chain.name);
+    const privateKey = getWarpWalletPrivateKeyFromConfig2(this.config, this.chain.name);
+    return {
+      provider: _MnemonicWalletProvider.PROVIDER_NAME,
+      address: wallet.address,
+      privateKey: privateKey || null,
+      mnemonic: mnemonic || null
+    };
+  }
+  async generate() {
+    const mnemonicRaw = bip39.generateMnemonic(wordlist, 256);
+    const mnemonic = normalizeMnemonic(mnemonicRaw);
+    validateMnemonicLength(mnemonic);
+    const wallet = HDNodeWallet.fromPhrase(mnemonic);
+    return {
+      provider: _MnemonicWalletProvider.PROVIDER_NAME,
+      address: wallet.address,
+      privateKey: null,
+      mnemonic
+    };
+  }
+  getWallet() {
+    if (this.wallet) return this.wallet;
+    const mnemonic = getWarpWalletMnemonicFromConfig2(this.config, this.chain.name);
+    if (!mnemonic) throw new Error("No mnemonic provided");
+    this.wallet = HDNodeWallet.fromPhrase(mnemonic.trim());
+    return this.wallet;
+  }
+};
+_MnemonicWalletProvider.PROVIDER_NAME = "mnemonic";
+var MnemonicWalletProvider = _MnemonicWalletProvider;
+
+// src/providers/ReadOnlyWalletProvider.ts
+import { getWarpWalletAddressFromConfig } from "@joai/warps";
+var ReadOnlyWalletProvider = class {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+  }
+  async getAddress() {
+    return getWarpWalletAddressFromConfig(this.config, this.chain.name);
+  }
+  async getPublicKey() {
+    return null;
+  }
+  async signTransaction(tx) {
+    const address = await this.getAddress();
+    throw new Error(`Wallet can not be used for signing: ${address}`);
+  }
+  async signMessage(message) {
+    const address = await this.getAddress();
+    throw new Error(`Wallet can not be used for signing: ${address}`);
+  }
+  async importFromMnemonic(mnemonic) {
+    const address = getWarpWalletAddressFromConfig(this.config, this.chain.name);
+    throw new Error(`Wallet can not be used for signing: ${address}`);
+  }
+  async importFromPrivateKey(privateKey) {
+    const address = getWarpWalletAddressFromConfig(this.config, this.chain.name);
+    throw new Error(`Wallet can not be used for signing: ${address}`);
+  }
+  async export() {
+    const address = getWarpWalletAddressFromConfig(this.config, this.chain.name);
+    throw new Error(`Wallet can not be used for signing: ${address}`);
+  }
+  async generate() {
+    const address = getWarpWalletAddressFromConfig(this.config, this.chain.name);
+    throw new Error(`Wallet can not be used for signing: ${address}`);
+  }
+};
+
+// src/tokens.ts
+import { WarpChainName as WarpChainName9 } from "@joai/warps";
+
+// src/tokens/arbitrum.ts
+import { WarpChainName } from "@joai/warps";
+var ArbitrumChain = WarpChainName.Arbitrum;
+var ArbitrumTokens = [
+  {
+    chain: ArbitrumChain,
+    identifier: "0x0000000000000000000000000000000000000000",
+    name: "Ether",
+    symbol: "ETH",
+    decimals: 18,
+    logoUrl: "https://assets.coingecko.com/coins/images/279/small/ethereum.png"
+  },
+  {
+    chain: ArbitrumChain,
+    identifier: "0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8",
+    name: "USD Coin",
+    symbol: "USDC",
+    decimals: 6,
+    logoUrl: "https://assets.coingecko.com/coins/images/6319/small/USD_Coin_icon.png"
+  },
+  {
+    chain: ArbitrumChain,
+    identifier: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+    name: "Tether USD",
+    symbol: "USDT",
+    decimals: 6,
+    logoUrl: "https://assets.coingecko.com/coins/images/325/small/Tether.png"
+  },
+  {
+    chain: ArbitrumChain,
+    identifier: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+    name: "Wrapped Ether",
+    symbol: "WETH",
+    decimals: 18,
+    logoUrl: "https://assets.coingecko.com/coins/images/2518/small/weth.png"
+  }
+];
+
+// src/tokens/arbitrum-sepolia.ts
+import { WarpChainName as WarpChainName2 } from "@joai/warps";
+var ArbitrumChain2 = WarpChainName2.Arbitrum;
+var ArbitrumSepoliaTokens = [
+  {
+    chain: ArbitrumChain2,
+    identifier: "0x0000000000000000000000000000000000000000",
+    name: "Ether",
+    symbol: "ETH",
+    decimals: 18,
+    logoUrl: "https://assets.coingecko.com/coins/images/279/small/ethereum.png"
+  },
+  {
+    chain: ArbitrumChain2,
+    identifier: "0x980B62Da83eFf3D4576C647993b0c1D7faf17c73",
+    name: "Wrapped Ether",
+    symbol: "WETH",
+    decimals: 18,
+    logoUrl: "https://assets.coingecko.com/coins/images/2518/small/weth.png"
+  },
+  {
+    chain: ArbitrumChain2,
+    identifier: "0xC6d2Bd6437655FBc6689Bfc987E09846aC4367Ed",
+    name: "Wrapped SET",
+    symbol: "WSET",
+    decimals: 18,
+    logoUrl: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/tokens/logos/set-black.svg"
+  }
+];
+
+// src/tokens/base.ts
+import { WarpChainName as WarpChainName3 } from "@joai/warps";
+var BaseChain = WarpChainName3.Base;
+var BaseTokens = [
+  {
+    chain: BaseChain,
+    identifier: "0x0000000000000000000000000000000000000000",
+    name: "Ether",
+    symbol: "ETH",
+    decimals: 18,
+    logoUrl: "https://assets.coingecko.com/coins/images/279/small/ethereum.png"
+  },
+  {
+    chain: BaseChain,
+    identifier: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    name: "USD Coin",
+    symbol: "USDC",
+    decimals: 6,
+    logoUrl: "https://assets.coingecko.com/coins/images/6319/small/USD_Coin_icon.png"
+  },
+  {
+    chain: BaseChain,
+    identifier: "0x4200000000000000000000000000000000000006",
+    name: "Wrapped Ether",
+    symbol: "WETH",
+    decimals: 18,
+    logoUrl: "https://assets.coingecko.com/coins/images/2518/small/weth.png"
+  },
+  {
+    chain: BaseChain,
+    identifier: "0x808456652fdb597867f38412077A9182bf77359F",
+    name: "Euro",
+    symbol: "EURC",
+    decimals: 6,
+    logoUrl: "https://assets.coingecko.com/coins/images/26045/standard/euro.png"
+  },
+  {
+    chain: BaseChain,
+    identifier: "0xcbB7C0006F23900c38EB856149F799620fcb8A4a",
+    name: "Coinbase Wrapped BTC",
+    symbol: "CBETH",
+    decimals: 8,
+    logoUrl: "https://assets.coingecko.com/coins/images/7598/small/wrapped_bitcoin_wbtc.png"
+  }
+];
+
+// src/tokens/base-sepolia.ts
+import { WarpChainName as WarpChainName4 } from "@joai/warps";
+var BaseChain2 = WarpChainName4.Base;
+var BaseSepoliaTokens = [
+  {
+    chain: BaseChain2,
+    identifier: "0x0000000000000000000000000000000000000000",
+    name: "Ether",
+    symbol: "ETH",
+    decimals: 18,
+    logoUrl: "https://assets.coingecko.com/coins/images/279/small/ethereum.png"
+  },
+  {
+    chain: BaseChain2,
+    identifier: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+    name: "USD",
+    symbol: "USDC",
+    decimals: 6,
+    logoUrl: "https://assets.coingecko.com/coins/images/6319/small/USD_Coin_icon.png"
+  },
+  {
+    chain: BaseChain2,
+    identifier: "0x808456652fdb597867f38412077A9182bf77359F",
+    name: "Euro",
+    symbol: "EURC",
+    decimals: 6,
+    logoUrl: "https://assets.coingecko.com/coins/images/26045/thumb/euro-coin.png?1655394420"
+  },
+  {
+    chain: BaseChain2,
+    identifier: "0xcbB7C0006F23900c38EB856149F799620fcb8A4a",
+    name: "Wrapped Bitcoin",
+    symbol: "WBTC",
+    decimals: 8,
+    logoUrl: "https://assets.coingecko.com/coins/images/7598/small/wrapped_bitcoin_wbtc.png"
+  }
+];
+
+// src/tokens/ethereum.ts
+import { WarpChainName as WarpChainName5 } from "@joai/warps";
+var EthereumChain = WarpChainName5.Ethereum;
+var EthereumTokens = [
+  {
+    chain: EthereumChain,
+    identifier: "0x0000000000000000000000000000000000000000",
+    name: "Ether",
+    symbol: "ETH",
+    decimals: 18,
+    logoUrl: "https://assets.coingecko.com/coins/images/279/small/ethereum.png"
+  },
+  {
+    chain: EthereumChain,
+    identifier: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    name: "USD Coin",
+    symbol: "USDC",
+    decimals: 6,
+    logoUrl: "https://assets.coingecko.com/coins/images/6319/small/USD_Coin_icon.png"
+  },
+  {
+    chain: EthereumChain,
+    identifier: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+    name: "Tether USD",
+    symbol: "USDT",
+    decimals: 6,
+    logoUrl: "https://assets.coingecko.com/coins/images/325/small/Tether.png"
+  },
+  {
+    chain: EthereumChain,
+    identifier: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599",
+    name: "Wrapped Bitcoin",
+    symbol: "WBTC",
+    decimals: 8,
+    logoUrl: "https://assets.coingecko.com/coins/images/7598/small/wrapped_bitcoin_wbtc.png"
+  },
+  {
+    chain: EthereumChain,
+    identifier: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+    name: "Wrapped Ether",
+    symbol: "WETH",
+    decimals: 18,
+    logoUrl: "https://assets.coingecko.com/coins/images/2518/small/weth.png"
+  },
+  {
+    chain: EthereumChain,
+    identifier: "0x6B175474E89094C44Da98b954EedeAC495271d0F",
+    name: "Dai Stablecoin",
+    symbol: "DAI",
+    decimals: 18,
+    logoUrl: "https://assets.coingecko.com/coins/images/9956/small/4943.png"
+  }
+];
+
+// src/tokens/ethereum-sepolia.ts
+import { WarpChainName as WarpChainName6 } from "@joai/warps";
+var EthereumChain2 = WarpChainName6.Ethereum;
+var EthereumSepoliaTokens = [
+  {
+    chain: EthereumChain2,
+    identifier: "0x0000000000000000000000000000000000000000",
+    name: "Ether",
+    symbol: "ETH",
+    decimals: 18,
+    logoUrl: "https://assets.coingecko.com/coins/images/279/small/ethereum.png"
+  },
+  {
+    chain: EthereumChain2,
+    identifier: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
+    name: "USD Coin",
+    symbol: "USDC",
+    decimals: 6,
+    logoUrl: "https://assets.coingecko.com/coins/images/6319/small/USD_Coin_icon.png"
+  },
+  {
+    chain: EthereumChain2,
+    identifier: "0x7169D38820dfd117C3FA1f22a697dBA58d90BA06",
+    name: "Tether USD",
+    symbol: "USDT",
+    decimals: 6,
+    logoUrl: "https://assets.coingecko.com/coins/images/325/small/Tether.png"
+  },
+  {
+    chain: EthereumChain2,
+    identifier: "0xfFf9976782d46CC05630D1f6eBAb18b2324d6B14",
+    name: "Wrapped Ether",
+    symbol: "WETH",
+    decimals: 18,
+    logoUrl: "https://assets.coingecko.com/coins/images/2518/small/weth.png"
+  },
+  {
+    chain: EthereumChain2,
+    identifier: "0xC6d2Bd6437655FBc6689Bfc987E09846aC4367Ed",
+    name: "Wrapped SET",
+    symbol: "WSET",
+    decimals: 18,
+    logoUrl: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/tokens/logos/set-black.svg"
+  }
+];
+
+// src/tokens/polygon.ts
+import { WarpChainName as WarpChainName7 } from "@joai/warps";
+var PolygonChain = WarpChainName7.Polygon;
+var PolygonTokens = [
+  {
+    chain: PolygonChain,
+    identifier: "0x0000000000000000000000000000000000000000",
+    name: "Polygon",
+    symbol: "MATIC",
+    decimals: 18,
+    logoUrl: "https://assets.coingecko.com/coins/images/4713/small/matic-token-icon.png"
+  },
+  {
+    chain: PolygonChain,
+    identifier: "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174",
+    name: "USD Coin",
+    symbol: "USDC",
+    decimals: 6,
+    logoUrl: "https://assets.coingecko.com/coins/images/6319/small/USD_Coin_icon.png"
+  },
+  {
+    chain: PolygonChain,
+    identifier: "0xc2132D05D31c914a87C6611C10748AEb04B58e8F",
+    name: "Tether USD",
+    symbol: "USDT",
+    decimals: 6,
+    logoUrl: "https://assets.coingecko.com/coins/images/325/small/Tether.png"
+  },
+  {
+    chain: PolygonChain,
+    identifier: "0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6",
+    name: "Wrapped Bitcoin",
+    symbol: "WBTC",
+    decimals: 8,
+    logoUrl: "https://assets.coingecko.com/coins/images/7598/small/wrapped_bitcoin_wbtc.png"
+  },
+  {
+    chain: PolygonChain,
+    identifier: "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619",
+    name: "Wrapped Ether",
+    symbol: "WETH",
+    decimals: 18,
+    logoUrl: "https://assets.coingecko.com/coins/images/2518/small/weth.png"
+  },
+  {
+    chain: PolygonChain,
+    identifier: "0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063",
+    name: "Dai Stablecoin",
+    symbol: "DAI",
+    decimals: 18,
+    logoUrl: "https://assets.coingecko.com/coins/images/9956/small/4943.png"
+  }
+];
+
+// src/tokens/polygon-mumbai.ts
+import { WarpChainName as WarpChainName8 } from "@joai/warps";
+var PolygonChain2 = WarpChainName8.Polygon;
+var PolygonMumbaiTokens = [
+  {
+    chain: PolygonChain2,
+    identifier: "0x0000000000000000000000000000000000000000",
+    name: "Polygon",
+    symbol: "MATIC",
+    decimals: 18,
+    logoUrl: "https://assets.coingecko.com/coins/images/4713/small/matic-token-icon.png"
+  },
+  {
+    chain: PolygonChain2,
+    identifier: "0x0FA8781a83E46826621b3BC094Ea2Aea2Cdd993B",
+    name: "USD Coin",
+    symbol: "USDC",
+    decimals: 6,
+    logoUrl: "https://assets.coingecko.com/coins/images/6319/small/USD_Coin_icon.png"
+  }
+];
+
+// src/tokens.ts
+var KnownTokens = {
+  [WarpChainName9.Ethereum]: {
+    mainnet: EthereumTokens,
+    testnet: EthereumSepoliaTokens,
+    devnet: EthereumSepoliaTokens
+  },
+  [WarpChainName9.Base]: {
+    mainnet: BaseTokens,
+    testnet: BaseSepoliaTokens,
+    devnet: BaseSepoliaTokens
+  },
+  [WarpChainName9.Arbitrum]: {
+    mainnet: ArbitrumTokens,
+    testnet: ArbitrumSepoliaTokens,
+    devnet: ArbitrumSepoliaTokens
+  },
+  [WarpChainName9.Polygon]: {
+    mainnet: PolygonTokens,
+    testnet: PolygonMumbaiTokens,
+    devnet: PolygonMumbaiTokens
+  }
+};
+var findKnownTokenById = (chain, env, id) => {
+  const chainTokens = KnownTokens[chain]?.[env] || [];
+  return chainTokens.find((token) => token.identifier === id) || null;
+};
+var getKnownTokensForChain = (chainName, env = "mainnet") => {
+  return KnownTokens[chainName]?.[env] || [];
+};
+
+// 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 WarpEvmDataLoader = class {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    const providerConfig = getProviderConfig(this.config, this.chain.name, this.config.env, this.chain.defaultApiUrl);
+    const network = new ethers3.Network(this.chain.name, parseInt(this.chain.chainId));
+    this.provider = new ethers3.JsonRpcProvider(providerConfig.url, network);
+    this.cache = new WarpCache2(config.env, config.cache);
+    this.uniswapService = new UniswapService(this.cache, parseInt(this.chain.chainId));
+  }
+  getRequiredConfirmations() {
+    if (this.config.env === "mainnet") {
+      return 12;
+    }
+    return 1;
+  }
+  async getAccount(address) {
+    const balance = await this.provider.getBalance(address);
+    return {
+      chain: this.chain.name,
+      address,
+      balance
+    };
+  }
+  async getAccountAssets(address) {
+    const account = await this.getAccount(address);
+    const tokenBalances = await this.getERC20TokenBalances(address);
+    let assets = account.balance > 0 ? [{ ...this.chain.nativeToken, amount: account.balance }] : [];
+    for (const tokenBalance of tokenBalances) {
+      if (tokenBalance.balance > 0n) {
+        assets.push({
+          chain: this.chain.name,
+          identifier: tokenBalance.tokenAddress,
+          name: tokenBalance.name,
+          symbol: tokenBalance.symbol,
+          amount: tokenBalance.balance,
+          decimals: tokenBalance.decimals,
+          logoUrl: tokenBalance.logoUrl || ""
+        });
+      }
+    }
+    return assets;
+  }
+  async getAsset(identifier) {
+    try {
+      console.log("WarpEvmDataLoader.getAsset", identifier);
+      if (identifier === this.chain.nativeToken.identifier) {
+        return this.chain.nativeToken;
+      }
+      const cacheKey = WarpCacheKey.Asset(this.config.env, this.chain.name, identifier);
+      const cachedAsset = this.cache.get(cacheKey);
+      if (cachedAsset) {
+        return cachedAsset;
+      }
+      console.log("WarpEvmDataLoader.getAsset: findKnownTokenById", this.chain.name, this.config.env, identifier);
+      const knownToken = findKnownTokenById(this.chain.name, this.config.env, identifier);
+      if (knownToken) {
+        return {
+          chain: this.chain.name,
+          identifier,
+          name: knownToken.name,
+          symbol: knownToken.symbol,
+          amount: 0n,
+          decimals: knownToken.decimals,
+          logoUrl: knownToken.logoUrl
+        };
+      }
+      const metadata = await this.getTokenMetadata(identifier);
+      const asset = {
+        chain: this.chain.name,
+        identifier,
+        name: metadata.name,
+        symbol: metadata.symbol,
+        amount: 0n,
+        decimals: metadata.decimals,
+        logoUrl: metadata.logoUrl
+      };
+      this.cache.set(cacheKey, asset, CacheTtl2.OneHour);
+      return asset;
+    } catch (error) {
+      return null;
+    }
+  }
+  async getAction(identifier, awaitCompleted = false) {
+    try {
+      const tx = await this.provider.getTransaction(identifier);
+      if (!tx) return null;
+      let receipt = await this.provider.getTransactionReceipt(identifier);
+      if (awaitCompleted) {
+        if (!receipt) {
+          receipt = await tx.wait();
+        } else {
+          const confirmations = this.getRequiredConfirmations();
+          const currentBlock = await this.provider.getBlockNumber();
+          const receiptBlock = receipt.blockNumber;
+          const confirmationsCount = currentBlock - receiptBlock;
+          if (confirmationsCount < confirmations) {
+            await tx.wait(confirmations);
+            receipt = await this.provider.getTransactionReceipt(identifier);
+          }
+        }
+      }
+      const block = await this.provider.getBlock(receipt?.blockNumber || tx.blockNumber || "latest");
+      const status = receipt ? receipt.status === 1 ? "success" : receipt.status === 0 ? "failed" : "pending" : "pending";
+      const error = receipt?.status === 0 ? "Transaction failed" : null;
+      return {
+        chain: this.chain.name,
+        id: tx.hash || identifier,
+        receiver: tx.to || "",
+        sender: tx.from,
+        value: tx.value,
+        function: tx.data && tx.data !== "0x" ? "contract_call" : "",
+        status,
+        createdAt: block?.timestamp ? new Date(Number(block.timestamp) * 1e3).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+        error,
+        tx: {
+          hash: tx.hash || "",
+          from: tx.from,
+          to: tx.to || "",
+          value: tx.value.toString(),
+          data: tx.data || "0x",
+          gasLimit: tx.gasLimit?.toString() || "0",
+          gasPrice: tx.gasPrice?.toString() || "0",
+          blockNumber: tx.blockNumber || 0,
+          blockHash: tx.blockHash || "",
+          transactionIndex: tx.index || 0,
+          status: receipt?.status
+        }
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+  async getAccountActions(address, options) {
+    return [];
+  }
+  async getERC20TokenBalances(address) {
+    const env = this.config.env === "mainnet" ? "mainnet" : "testnet";
+    const tokens = getKnownTokensForChain(this.chain.name, env);
+    const balanceReqs = tokens.map((token) => this.getTokenBalance(address, token.identifier).catch(() => 0n));
+    const balances = await Promise.all(balanceReqs);
+    return balances.map((balance, index) => ({ balance, token: tokens[index] })).filter(({ balance }) => balance > 0n).map(({ balance, token }) => ({
+      tokenAddress: token.identifier,
+      balance,
+      name: token.name,
+      symbol: token.symbol,
+      decimals: token.decimals || 18,
+      logoUrl: getWarpChainAssetLogoUrl(token, this.config) || ""
+    }));
+  }
+  async getTokenBalance(address, tokenAddress) {
+    const contract = new ethers3.Contract(tokenAddress, ERC20_ABI, this.provider);
+    const balance = await contract.balanceOf(address);
+    return balance;
+  }
+  async getTokenMetadata(tokenAddress) {
+    const uniswapMetadata = await this.uniswapService.getTokenMetadata(tokenAddress);
+    if (uniswapMetadata) {
+      return uniswapMetadata;
+    }
+    const contract = new ethers3.Contract(tokenAddress, ERC20_ABI, this.provider);
+    const [name, symbol, decimals] = await Promise.all([
+      contract.name().catch(() => "Unknown Token"),
+      contract.symbol().catch(() => "UNKNOWN"),
+      contract.decimals().catch(() => 18)
+    ]);
+    return {
+      name: name || "Unknown Token",
+      symbol: symbol || "UNKNOWN",
+      decimals: decimals || 18,
+      logoUrl: ""
+    };
+  }
+};
+
+// src/WarpEvmExecutor.ts
+import {
+  applyOutputToMessages,
+  extractResolvedInputValues as extractResolvedInputValues2,
+  getNextInfo,
+  getProviderConfig as getProviderConfig3,
+  getWarpActionByIndex,
+  getWarpWalletAddressFromConfig as getWarpWalletAddressFromConfig3
+} from "@joai/warps";
+import { ethers as ethers6 } from "ethers";
+
+// src/constants.ts
+var WarpEvmConstants = {
+  GasLimit: {
+    Default: 21e3,
+    ContractCall: 1e5,
+    ContractDeploy: 5e5,
+    Transfer: 21e3,
+    TokenTransfer: 65e3,
+    // ERC-20 transfer gas limit
+    Approve: 46e3,
+    Swap: 2e5
+  },
+  GasPrice: {
+    Default: "1200010"
+  },
+  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 PolygonExplorers = /* @__PURE__ */ ((PolygonExplorers2) => {
+  PolygonExplorers2["Polygonscan"] = "polygonscan";
+  PolygonExplorers2["PolygonscanMumbai"] = "polygonscan_mumbai";
+  PolygonExplorers2["BlockscoutPolygon"] = "blockscout_polygon";
+  PolygonExplorers2["BlockscoutPolygonMumbai"] = "blockscout_polygon_mumbai";
+  return PolygonExplorers2;
+})(PolygonExplorers || {});
+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 */]
+  },
+  polygon: {
+    mainnet: ["polygonscan" /* Polygonscan */, "blockscout_polygon" /* BlockscoutPolygon */],
+    testnet: ["polygonscan_mumbai" /* PolygonscanMumbai */, "blockscout_polygon_mumbai" /* BlockscoutPolygonMumbai */],
+    devnet: ["polygonscan_mumbai" /* PolygonscanMumbai */, "blockscout_polygon_mumbai" /* BlockscoutPolygonMumbai */]
+  }
+};
+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",
+  ["polygonscan" /* Polygonscan */]: "https://polygonscan.com",
+  ["polygonscan_mumbai" /* PolygonscanMumbai */]: "https://mumbai.polygonscan.com",
+  ["blockscout_polygon" /* BlockscoutPolygon */]: "https://polygon.blockscout.com",
+  ["blockscout_polygon_mumbai" /* BlockscoutPolygonMumbai */]: "https://mumbai.blockscout.com"
+};
+var EvmChainIds = {
+  Ethereum: {
+    Mainnet: 1,
+    Goerli: 5,
+    Sepolia: 11155111
+  },
+  Polygon: {
+    Mainnet: 137,
+    Mumbai: 80001
+  },
+  Arbitrum: {
+    Mainnet: 42161,
+    Sepolia: 421614
+  },
+  Base: {
+    Mainnet: 8453,
+    Sepolia: 84532
+  },
+  Optimism: {
+    Mainnet: 10,
+    Sepolia: 11155420
+  }
+};
+var EvmChainIdMap = {
+  "ethereum:mainnet": EvmChainIds.Ethereum.Mainnet,
+  "ethereum:goerli": EvmChainIds.Ethereum.Goerli,
+  "ethereum:sepolia": EvmChainIds.Ethereum.Sepolia,
+  "polygon:mainnet": EvmChainIds.Polygon.Mainnet,
+  "polygon:mumbai": EvmChainIds.Polygon.Mumbai,
+  "arbitrum:mainnet": EvmChainIds.Arbitrum.Mainnet,
+  "arbitrum:sepolia": EvmChainIds.Arbitrum.Sepolia,
+  "base:mainnet": EvmChainIds.Base.Mainnet,
+  "base:sepolia": EvmChainIds.Base.Sepolia,
+  "optimism:mainnet": EvmChainIds.Optimism.Mainnet,
+  "optimism:sepolia": EvmChainIds.Optimism.Sepolia
+};
+var SupportedEvmChainIds = [
+  EvmChainIds.Ethereum.Mainnet,
+  EvmChainIds.Ethereum.Goerli,
+  EvmChainIds.Ethereum.Sepolia,
+  EvmChainIds.Polygon.Mainnet,
+  EvmChainIds.Polygon.Mumbai,
+  EvmChainIds.Arbitrum.Mainnet,
+  EvmChainIds.Arbitrum.Sepolia,
+  EvmChainIds.Base.Mainnet,
+  EvmChainIds.Base.Sepolia,
+  EvmChainIds.Optimism.Mainnet,
+  EvmChainIds.Optimism.Sepolia
+];
+
+// src/WarpEvmOutput.ts
+import {
+  evaluateOutputCommon,
+  extractResolvedInputValues,
+  getProviderConfig as getProviderConfig2,
+  getWarpWalletAddressFromConfig as getWarpWalletAddressFromConfig2,
+  parseOutputOutIndex,
+  WarpConstants as WarpConstants2,
+  WarpCache as WarpCache3,
+  WarpCacheKey as WarpCacheKey2
+} from "@joai/warps";
+import { ethers as ethers5 } from "ethers";
+
+// src/WarpEvmSerializer.ts
+import {
+  WarpConstants,
+  WarpSerializer
+} from "@joai/warps";
+import { ethers as ethers4 } from "ethers";
+var SplitParamsRegex = new RegExp(`${WarpConstants.ArgParamsSeparator}(.*)`);
+var WarpEvmSerializer = class {
+  constructor() {
+    this.coreSerializer = new WarpSerializer();
+  }
+  typedToString(value) {
+    if (typeof value === "string") {
+      if (ethers4.isAddress(value)) {
+        return `address:${value}`;
+      }
+      if (ethers4.isHexString(value) && !ethers4.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":
+        const hexValue = String(value);
+        return hexValue.startsWith("0x") ? hexValue : `0x${hexValue}`;
+      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.startsWith("0x") ? stringValue : `0x${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/WarpEvmOutput.ts
+var WarpEvmOutput = class {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    this.serializer = new WarpEvmSerializer();
+    const providerConfig = getProviderConfig2(this.config, this.chain.name, this.config.env, this.chain.defaultApiUrl);
+    const network = new ethers5.Network(this.chain.name, parseInt(this.chain.chainId));
+    this.provider = new ethers5.JsonRpcProvider(providerConfig.url, network);
+    this.cache = new WarpCache3(config.env, config.cache);
+  }
+  async getActionExecution(warp, actionIndex, tx) {
+    const inputs = this.cache.get(WarpCacheKey2.WarpExecutable(this.config.env, warp.meta?.hash || "", actionIndex)) ?? [];
+    const resolvedInputs = extractResolvedInputValues(inputs);
+    if (!tx) {
+      return this.createFailedExecution(warp, actionIndex, resolvedInputs);
+    }
+    if ("status" in tx && typeof tx.status === "string") {
+      return this.handleWarpChainAction(warp, actionIndex, tx, resolvedInputs);
+    }
+    return this.handleTransactionReceipt(warp, actionIndex, tx, resolvedInputs);
+  }
+  createFailedExecution(warp, actionIndex, resolvedInputs = []) {
+    return {
+      status: "error",
+      warp,
+      action: actionIndex,
+      user: getWarpWalletAddressFromConfig2(this.config, this.chain.name),
+      txHash: "",
+      tx: null,
+      next: null,
+      values: { string: [], native: [], mapped: {} },
+      output: {},
+      messages: {},
+      destination: null,
+      resolvedInputs
+    };
+  }
+  handleWarpChainAction(warp, actionIndex, tx, resolvedInputs = []) {
+    const success = tx.status === "success";
+    const transactionHash = tx.id || tx.tx?.hash || "";
+    const gasUsed = tx.tx?.gasLimit || "0";
+    const gasPrice = tx.tx?.gasPrice || "0";
+    const blockNumber = tx.tx?.blockNumber || "0";
+    const rawValues = [transactionHash, blockNumber, gasUsed, gasPrice];
+    const stringValues = rawValues.map(String);
+    return {
+      status: success ? "success" : "error",
+      warp,
+      action: actionIndex,
+      user: getWarpWalletAddressFromConfig2(this.config, this.chain.name),
+      txHash: transactionHash,
+      tx,
+      next: null,
+      values: { string: stringValues, native: rawValues, mapped: {} },
+      output: {},
+      messages: {},
+      destination: null,
+      resolvedInputs
+    };
+  }
+  handleTransactionReceipt(warp, actionIndex, tx, resolvedInputs = []) {
+    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"
+    }));
+    const rawValues = [transactionHash, blockNumber, gasUsed, gasPrice, ...logs.length > 0 ? logs : []];
+    const stringValues = rawValues.map(String);
+    return {
+      status: success ? "success" : "error",
+      warp,
+      action: actionIndex,
+      user: getWarpWalletAddressFromConfig2(this.config, this.chain.name),
+      txHash: transactionHash,
+      tx: {
+        ...tx,
+        status: tx.status
+      },
+      next: null,
+      values: { string: stringValues, native: rawValues, mapped: {} },
+      output: {},
+      messages: {},
+      destination: null,
+      resolvedInputs
+    };
+  }
+  async extractQueryOutput(warp, typedValues, actionIndex, inputs) {
+    const stringValues = typedValues.map((t) => this.serializer.typedToString(t));
+    const nativeValues = typedValues.map((t) => this.serializer.typedToNative(t)[1]);
+    const values = { string: stringValues, native: nativeValues, mapped: {} };
+    let output = {};
+    if (!warp.output) return { values, output };
+    const getNestedValue = (path) => {
+      const indices = path.split(".").slice(1).map((i) => parseInt(i) - 1);
+      if (indices.length === 0) return void 0;
+      let value = nativeValues[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.output)) {
+      if (path.startsWith(WarpConstants2.Transform.Prefix)) continue;
+      const currentActionIndex = parseOutputOutIndex(path);
+      if (currentActionIndex !== null && currentActionIndex !== actionIndex) {
+        output[key] = null;
+        continue;
+      }
+      if (path.startsWith("out.") || path === "out" || path.startsWith("out[")) {
+        output[key] = getNestedValue(path) || null;
+      } else {
+        output[key] = path;
+      }
+    }
+    return { values, output: await evaluateOutputCommon(warp, output, actionIndex, inputs, this.serializer.coreSerializer, this.config) };
+  }
+  async getTransactionStatus(txHash) {
+    try {
+      const receipt = await this.provider.getTransactionReceipt(txHash);
+      if (!receipt) {
+        return { status: "pending" };
+      }
+      return {
+        status: receipt.status === 1 ? "confirmed" : "failed",
+        blockNumber: receipt.blockNumber,
+        gasUsed: receipt.gasUsed
+      };
+    } catch (error) {
+      throw new Error(`Failed to get transaction status: ${error}`);
+    }
+  }
+  async getTransactionReceipt(txHash) {
+    try {
+      return await this.provider.getTransactionReceipt(txHash);
+    } catch (error) {
+      return null;
+    }
+  }
+};
+
+// src/WarpEvmExecutor.ts
+var WarpEvmExecutor = class {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    this.serializer = new WarpEvmSerializer();
+    const providerConfig = getProviderConfig3(this.config, chain.name, this.config.env, this.chain.defaultApiUrl);
+    const network = new ethers6.Network(this.chain.name, parseInt(this.chain.chainId));
+    this.provider = new ethers6.JsonRpcProvider(providerConfig.url, network);
+    this.output = new WarpEvmOutput(config, this.chain);
+  }
+  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 = getWarpWalletAddressFromConfig3(this.config, executable.chain.name);
+    if (!userWallet) throw new Error("WarpEvmExecutor: createTransfer - user address not set");
+    if (!ethers6.isAddress(executable.destination)) {
+      throw new Error(`WarpEvmExecutor: Invalid destination address: ${executable.destination}`);
+    }
+    if (executable.transfers && executable.transfers.length > 0) {
+      return this.createTokenTransferTransaction(executable, userWallet);
+    }
+    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 = getWarpWalletAddressFromConfig3(this.config, 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 (!ethers6.isAddress(executable.destination)) throw new Error(`WarpEvmExecutor: Invalid contract address: ${executable.destination}`);
+    try {
+      let iface;
+      try {
+        iface = new ethers6.Interface(JSON.parse(action.abi));
+      } catch {
+        iface = new ethers6.Interface([action.abi]);
+      }
+      const funcFragment = iface.getFunction(action.func);
+      if (!funcFragment) throw new Error(`WarpEvmExecutor: Function ${action.func} not found in ABI`);
+      const nativeArgs = this.prepareNativeArgs(executable.args, funcFragment);
+      console.log("Native args:", nativeArgs);
+      const encodedData = iface.encodeFunctionData(action.func, nativeArgs);
+      const value = this.getPayableValue(executable, funcFragment);
+      console.log("Encoded data:", encodedData);
+      console.log("Value:", value);
+      const tx = {
+        to: executable.destination,
+        value,
+        data: encodedData
+      };
+      return this.estimateGasAndSetDefaults(tx, userWallet);
+    } catch (error) {
+      throw new Error(`WarpEvmExecutor: Failed to encode function data for ${action.func}: ${error}`);
+    }
+  }
+  async createTokenTransferTransaction(executable, userWallet) {
+    if (executable.transfers.length === 0) throw new Error("WarpEvmExecutor: No transfers provided");
+    if (!this.chain.nativeToken?.identifier) throw new Error("WarpEvmExecutor: No native token defined for this chain");
+    const nativeTokenTransfers = executable.transfers.filter((transfer) => transfer.identifier === this.chain.nativeToken.identifier);
+    const erc20Transfers = executable.transfers.filter((transfer) => transfer.identifier !== this.chain.nativeToken.identifier);
+    if (nativeTokenTransfers.length === 1 && erc20Transfers.length === 0) {
+      const transfer = nativeTokenTransfers[0];
+      if (transfer.amount <= 0n) throw new Error("WarpEvmExecutor: Native token transfer amount must be positive");
+      const tx = {
+        to: executable.destination,
+        value: transfer.amount,
+        data: "0x"
+      };
+      return this.estimateGasAndSetDefaults(tx, userWallet);
+    }
+    if (nativeTokenTransfers.length === 0 && erc20Transfers.length === 1) {
+      return this.createSingleTokenTransfer(executable, erc20Transfers[0], userWallet);
+    }
+    if (executable.transfers.length > 1) throw new Error("WarpEvmExecutor: Multiple token transfers not yet supported");
+    throw new Error("WarpEvmExecutor: Invalid transfer configuration");
+  }
+  async createSingleTokenTransfer(executable, transfer, userWallet) {
+    if (!ethers6.isAddress(transfer.identifier)) {
+      throw new Error(`WarpEvmExecutor: Invalid token address: ${transfer.identifier}`);
+    }
+    const transferInterface = new ethers6.Interface(["function transfer(address to, uint256 amount) returns (bool)"]);
+    const encodedData = transferInterface.encodeFunctionData("transfer", [executable.destination, transfer.amount]);
+    const tx = {
+      to: transfer.identifier,
+      value: 0n,
+      data: encodedData
+    };
+    return this.estimateGasAndSetDefaults(tx, userWallet);
+  }
+  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 (!ethers6.isAddress(executable.destination)) throw new Error(`WarpEvmExecutor: Invalid address for query: ${executable.destination}`);
+    try {
+      let iface;
+      try {
+        iface = new ethers6.Interface(JSON.parse(action.abi));
+      } catch {
+        iface = new ethers6.Interface([action.abi]);
+      }
+      const funcFragment = iface.getFunction(action.func);
+      if (!funcFragment) throw new Error(`WarpEvmExecutor: Function ${action.func} not found in ABI`);
+      const nativeArgs = this.prepareNativeArgs(executable.args, funcFragment);
+      const encodedData = iface.encodeFunctionData(action.func, nativeArgs);
+      const result = await this.provider.call({
+        to: executable.destination,
+        data: encodedData
+      });
+      const decodedResult = iface.decodeFunctionResult(action.func, result);
+      const isSuccess = true;
+      const { values, output } = await this.output.extractQueryOutput(
+        executable.warp,
+        decodedResult,
+        executable.action,
+        executable.resolvedInputs
+      );
+      const next = getNextInfo(this.config, [], executable.warp, executable.action, output);
+      const destinationInput = executable.resolvedInputs.find((i) => i.input.position === "receiver" || i.input.position === "destination");
+      const destination = destinationInput?.value || executable.destination;
+      const resolvedInputs = extractResolvedInputValues2(executable.resolvedInputs);
+      return {
+        status: isSuccess ? "success" : "error",
+        warp: executable.warp,
+        action: executable.action,
+        user: getWarpWalletAddressFromConfig3(this.config, executable.chain.name),
+        txHash: null,
+        tx: null,
+        next,
+        values,
+        output: { ...output, _DATA: decodedResult },
+        messages: applyOutputToMessages(executable.warp, output, this.config),
+        destination,
+        resolvedInputs
+      };
+    } catch (error) {
+      const destinationInput = executable.resolvedInputs.find((i) => i.input.position === "receiver" || i.input.position === "destination");
+      const destination = destinationInput?.value || executable.destination;
+      const resolvedInputs = extractResolvedInputValues2(executable.resolvedInputs);
+      return {
+        status: "error",
+        warp: executable.warp,
+        action: executable.action,
+        user: getWarpWalletAddressFromConfig3(this.config, executable.chain.name),
+        txHash: null,
+        tx: null,
+        next: null,
+        values: { string: [], native: [], mapped: {} },
+        output: { _DATA: error },
+        messages: {},
+        destination,
+        resolvedInputs
+      };
+    }
+  }
+  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,
+          chainId: parseInt(this.chain.chainId),
+          gasLimit: gasEstimate,
+          maxFeePerGas: feeData.maxFeePerGas,
+          maxPriorityFeePerGas: feeData.maxPriorityFeePerGas
+        };
+      } else if (feeData.gasPrice) {
+        return {
+          ...tx,
+          chainId: parseInt(this.chain.chainId),
+          gasLimit: gasEstimate,
+          gasPrice: feeData.gasPrice
+        };
+      } else {
+        return {
+          ...tx,
+          chainId: parseInt(this.chain.chainId),
+          gasLimit: gasEstimate,
+          gasPrice: ethers6.parseUnits(WarpEvmConstants.GasPrice.Default, "wei")
+        };
+      }
+    } catch (error) {
+      let defaultGasLimit = BigInt(WarpEvmConstants.GasLimit.Default);
+      if (tx.data && tx.data !== "0x") {
+        if (tx.data.startsWith("0xa9059cbb")) {
+          defaultGasLimit = BigInt(WarpEvmConstants.GasLimit.TokenTransfer);
+        } else {
+          defaultGasLimit = BigInt(WarpEvmConstants.GasLimit.ContractCall);
+        }
+      } else {
+        defaultGasLimit = BigInt(WarpEvmConstants.GasLimit.Transfer);
+      }
+      return {
+        ...tx,
+        chainId: parseInt(this.chain.chainId),
+        gasLimit: defaultGasLimit,
+        gasPrice: ethers6.parseUnits(WarpEvmConstants.GasPrice.Default, "wei")
+      };
+    }
+  }
+  async verifyMessage(message, signature) {
+    try {
+      const recoveredAddress = ethers6.verifyMessage(message, signature);
+      return recoveredAddress;
+    } catch (error) {
+      throw new Error(`Failed to verify message: ${error}`);
+    }
+  }
+  getPayableValue(executable, funcFragment) {
+    if (funcFragment.stateMutability !== "payable") {
+      return executable.value;
+    }
+    const nativeTokenId = this.chain.nativeToken?.identifier;
+    const zeroAddress = "0x0000000000000000000000000000000000000000";
+    const nativeTokenTransfer = nativeTokenId ? executable.transfers.find((transfer) => transfer.identifier === nativeTokenId || transfer.identifier === zeroAddress) : void 0;
+    if (nativeTokenTransfer) {
+      return nativeTokenTransfer.amount;
+    }
+    const nativeTokenAsset = this.findNativeTokenAsset(executable.resolvedInputs, nativeTokenId, zeroAddress);
+    if (nativeTokenAsset) {
+      return nativeTokenAsset.amount;
+    }
+    return executable.value;
+  }
+  findNativeTokenAsset(resolvedInputs, nativeTokenId, zeroAddress) {
+    for (const input of resolvedInputs) {
+      if (input.input.type === "asset" && input.value) {
+        const [, assetValue] = this.serializer.coreSerializer.stringToNative(input.value);
+        const asset = assetValue;
+        if (asset && "amount" in asset) {
+          if (asset.identifier === nativeTokenId || asset.identifier === zeroAddress) {
+            return asset;
+          }
+        }
+      }
+    }
+    return null;
+  }
+  prepareNativeArgs(args, funcFragment) {
+    return args.map((arg, index) => {
+      const nativeValue = this.serializer.coreSerializer.stringToNative(arg)[1];
+      const paramType = funcFragment.inputs[index]?.type;
+      if (paramType === "bytes32" && typeof nativeValue === "string") {
+        let hexValue = nativeValue;
+        if (!hexValue.startsWith("0x")) {
+          hexValue = "0x" + hexValue;
+        }
+        if (hexValue.length !== 66) {
+          hexValue = ethers6.zeroPadValue(hexValue, 32);
+        }
+        return hexValue;
+      }
+      return nativeValue;
+    });
+  }
+};
+
+// 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;
+  }
+  getAssetUrls(identifier) {
+    const explorers = this.getAllExplorers();
+    const urls = {};
+    explorers.forEach((explorer) => {
+      const url = ExplorerUrls[explorer];
+      if (url) {
+        urls[explorer] = `${url}/token/${identifier}`;
+      }
+    });
+    return urls;
+  }
+  getContractUrls(address) {
+    const explorers = this.getAllExplorers();
+    const urls = {};
+    explorers.forEach((explorer) => {
+      const url = ExplorerUrls[explorer];
+      if (url) {
+        urls[explorer] = `${url}/address/${address}`;
+      }
+    });
+    return urls;
+  }
+  getBlockUrls(blockNumber) {
+    const explorers = this.getAllExplorers();
+    const urls = {};
+    explorers.forEach((explorer) => {
+      const url = ExplorerUrls[explorer];
+      if (url) {
+        urls[explorer] = `${url}/block/${blockNumber}`;
+      }
+    });
+    return urls;
+  }
+};
+
+// src/WarpEvmWallet.ts
+import {
+  getProviderConfig as getProviderConfig4
+} from "@joai/warps";
+import { registerExactEvmScheme } from "@x402/evm/exact/client";
+import { ethers as ethers7 } from "ethers";
+import { privateKeyToAccount } from "viem/accounts";
+var WarpEvmWallet = class {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    this.cachedAddress = null;
+    this.cachedPublicKey = null;
+    const providerConfig = getProviderConfig4(config, chain.name, config.env, chain.defaultApiUrl);
+    this.provider = new ethers7.JsonRpcProvider(providerConfig.url);
+    this.walletProvider = this.createProvider();
+    const wallet = config.user?.wallets?.[chain.name];
+    if (typeof wallet === "string") {
+      this.cachedAddress = wallet;
+    } else if (this.walletProvider instanceof PrivateKeyWalletProvider || this.walletProvider instanceof MnemonicWalletProvider) {
+      try {
+        const w = this.walletProvider.getWalletInstance();
+        this.cachedAddress = w.address;
+        const pk = w.signingKey.publicKey;
+        this.cachedPublicKey = pk.startsWith("0x") ? pk.slice(2) : pk;
+      } catch {
+      }
+    }
+  }
+  async signTransaction(tx) {
+    if (!tx || typeof tx !== "object") throw new Error("Invalid transaction object");
+    if (!this.walletProvider) throw new Error("No wallet provider available");
+    if (this.walletProvider instanceof ReadOnlyWalletProvider) throw new Error(`Wallet (${this.chain.name}) is read-only`);
+    if (tx.nonce === void 0) {
+      const address = await this.getAddressAsync();
+      if (address) {
+        tx.nonce = await this.provider.getTransactionCount(address, "pending");
+      }
+    }
+    this.normalizeFees(tx);
+    return await this.walletProvider.signTransaction(tx);
+  }
+  async signTransactions(txs) {
+    if (txs.length === 0) return [];
+    if (!this.walletProvider) throw new Error("No wallet provider available");
+    const address = await this.getAddressAsync();
+    if (!address) throw new Error("No wallet address available");
+    const currentNonce = await this.provider.getTransactionCount(address, "pending");
+    const signedTxs = [];
+    for (let i = 0; i < txs.length; i++) {
+      const tx = { ...txs[i] };
+      if (tx.nonce === void 0) {
+        tx.nonce = currentNonce + i;
+      }
+      if (i > 0 && (this.walletProvider instanceof PrivateKeyWalletProvider || this.walletProvider instanceof MnemonicWalletProvider)) {
+        this.adjustFeesForMultipleTransactions(tx, i);
+      }
+      this.normalizeFees(tx);
+      signedTxs.push(await this.walletProvider.signTransaction(tx));
+    }
+    return signedTxs;
+  }
+  async signMessage(message) {
+    if (!this.walletProvider) throw new Error("No wallet provider available");
+    if (this.walletProvider instanceof ReadOnlyWalletProvider) throw new Error(`Wallet (${this.chain.name}) is read-only`);
+    return await this.walletProvider.signMessage(message);
+  }
+  async sendTransaction(tx) {
+    if (!tx || typeof tx !== "object") throw new Error("Invalid transaction object");
+    if (!tx.signature) throw new Error("Transaction must be signed before sending");
+    if (!this.walletProvider) throw new Error("No wallet provider available");
+    if (typeof tx.signature === "string" && tx.signature.startsWith("0x")) {
+      const txResponse = await this.provider.broadcastTransaction(tx.signature);
+      return txResponse.hash;
+    }
+    if (this.walletProvider instanceof PrivateKeyWalletProvider || this.walletProvider instanceof MnemonicWalletProvider) {
+      const wallet = this.walletProvider.getWalletInstance();
+      const connectedWallet = wallet.connect(this.provider);
+      const txResponse = await connectedWallet.sendTransaction(tx);
+      return txResponse.hash;
+    }
+    throw new Error("Wallet provider does not support sending transactions");
+  }
+  async sendTransactions(txs) {
+    return Promise.all(txs.map(async (tx) => this.sendTransaction(tx)));
+  }
+  async importFromMnemonic(mnemonic) {
+    const walletProvider = this.createProviderForOperation("mnemonic");
+    return await walletProvider.importFromMnemonic(mnemonic);
+  }
+  async importFromPrivateKey(privateKey) {
+    const walletProvider = this.createProviderForOperation("privateKey");
+    return await walletProvider.importFromPrivateKey(privateKey);
+  }
+  async export(provider) {
+    const walletProvider = this.createProviderForOperation(provider);
+    return await walletProvider.export();
+  }
+  async generate(provider) {
+    const walletProvider = this.createProviderForOperation(provider);
+    return await walletProvider.generate();
+  }
+  getAddress() {
+    return this.cachedAddress;
+  }
+  getPublicKey() {
+    return this.cachedPublicKey;
+  }
+  async registerX402Handlers(client) {
+    if (!this.walletProvider) throw new Error("No wallet provider available");
+    const provider = this.walletProvider;
+    const getInstance = provider.getWalletInstance;
+    if (typeof getInstance !== "function") throw new Error("Wallet provider does not have getWalletInstance method");
+    const wallet = getInstance();
+    if (!wallet || !wallet.privateKey) throw new Error("Wallet instance does not have private key");
+    const signer = privateKeyToAccount(wallet.privateKey);
+    const handlers = {};
+    for (const chainId of SupportedEvmChainIds) {
+      handlers[`eip155:${chainId}`] = () => {
+        registerExactEvmScheme(client, { signer });
+      };
+    }
+    return handlers;
+  }
+  createProvider() {
+    const wallet = this.config.user?.wallets?.[this.chain.name];
+    if (!wallet) return null;
+    if (typeof wallet === "string") return new ReadOnlyWalletProvider(this.config, this.chain);
+    return this.createProviderForOperation(wallet.provider);
+  }
+  async getAddressAsync() {
+    if (this.cachedAddress !== null) return this.cachedAddress;
+    if (!this.walletProvider) return null;
+    this.cachedAddress = await this.walletProvider.getAddress();
+    if (!this.cachedPublicKey) this.cachedPublicKey = await this.walletProvider.getPublicKey();
+    return this.cachedAddress;
+  }
+  createProviderForOperation(provider) {
+    const customWalletProviders = this.config.walletProviders?.[this.chain.name];
+    const providerFactory = customWalletProviders?.[provider];
+    if (providerFactory) {
+      const walletProvider = providerFactory(this.config, this.chain);
+      if (!walletProvider) throw new Error(`Custom wallet provider factory returned null for ${provider}`);
+      return walletProvider;
+    }
+    if (provider === "privateKey") return new PrivateKeyWalletProvider(this.config, this.chain);
+    if (provider === "mnemonic") return new MnemonicWalletProvider(this.config, this.chain);
+    throw new Error(`Unsupported wallet provider for ${this.chain.name}: ${provider}`);
+  }
+  normalizeFees(tx) {
+    const hasEip1559Fields = tx.maxFeePerGas !== void 0 && tx.maxPriorityFeePerGas !== void 0;
+    const hasLegacyFields = tx.gasPrice !== void 0 && !hasEip1559Fields;
+    if (hasEip1559Fields) {
+      const maxFee = this.parseBigInt(tx.maxFeePerGas);
+      const maxPriorityFee = this.parseBigInt(tx.maxPriorityFeePerGas);
+      tx.maxFeePerGas = maxFee;
+      tx.maxPriorityFeePerGas = this.normalizePriorityFee(maxFee, maxPriorityFee);
+    } else if (hasLegacyFields) {
+      const gasPrice = this.parseBigInt(tx.gasPrice);
+      tx.maxFeePerGas = gasPrice;
+      tx.maxPriorityFeePerGas = this.normalizePriorityFee(gasPrice, gasPrice * 9n / 10n);
+      delete tx.gasPrice;
+    } else {
+      const defaultMaxFee = 1000000000n;
+      tx.maxFeePerGas = defaultMaxFee;
+      tx.maxPriorityFeePerGas = defaultMaxFee / 10n;
+    }
+  }
+  parseBigInt(value) {
+    if (value === void 0 || value === null) return void 0;
+    if (typeof value === "bigint") return value;
+    return BigInt(value);
+  }
+  adjustFeesForMultipleTransactions(tx, index) {
+    const priorityReduction = BigInt(index * 1e9);
+    const minGasPrice = BigInt(1e9);
+    if (tx.maxFeePerGas && tx.maxPriorityFeePerGas) {
+      const maxFee = this.parseBigInt(tx.maxFeePerGas);
+      const maxPriorityFee = this.parseBigInt(tx.maxPriorityFeePerGas);
+      const reducedMaxFee = maxFee > priorityReduction ? maxFee - priorityReduction : minGasPrice;
+      const reducedMaxPriorityFee = maxPriorityFee > priorityReduction ? maxPriorityFee - priorityReduction : minGasPrice;
+      tx.maxFeePerGas = reducedMaxFee;
+      tx.maxPriorityFeePerGas = this.normalizePriorityFee(reducedMaxFee, reducedMaxPriorityFee);
+      delete tx.gasPrice;
+    } else if (tx.gasPrice) {
+      tx.gasPrice = tx.gasPrice > priorityReduction ? tx.gasPrice - priorityReduction : minGasPrice;
+      delete tx.maxFeePerGas;
+      delete tx.maxPriorityFeePerGas;
+    }
+  }
+  normalizePriorityFee(maxFee, maxPriorityFee) {
+    if (maxFee <= 0n) return 1n;
+    if (maxPriorityFee <= maxFee) return maxPriorityFee;
+    const safeFee = maxFee / 10n;
+    return safeFee < 1n ? 1n : safeFee;
+  }
+};
+
+// src/chains/common.ts
+var createEvmAdapter = (chainName, chainInfos) => {
+  return (config, fallback) => {
+    if (!fallback) throw new Error(`${chainName} adapter requires a fallback adapter`);
+    return {
+      chainInfo: chainInfos[config.env],
+      builder: () => fallback.builder(),
+      executor: new WarpEvmExecutor(config, chainInfos[config.env]),
+      output: new WarpEvmOutput(config, chainInfos[config.env]),
+      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]),
+      wallet: new WarpEvmWallet(config, chainInfos[config.env])
+    };
+  };
+};
+
+// src/chains/arbitrum.ts
+var NativeTokenArb = {
+  chain: WarpChainName10.Arbitrum,
+  identifier: "ARB",
+  symbol: "ARB",
+  name: "Arbitrum",
+  decimals: 18,
+  logoUrl: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/tokens/logos/arb.svg"
+};
+var ArbitrumAdapter = createEvmAdapter(WarpChainName10.Arbitrum, {
+  mainnet: {
+    name: WarpChainName10.Arbitrum,
+    displayName: "Arbitrum",
+    chainId: "42161",
+    blockTime: 1e3,
+    addressHrp: "0x",
+    defaultApiUrl: "https://arb1.arbitrum.io/rpc",
+    logoUrl: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/chains/logos/arbitrum.svg",
+    nativeToken: NativeTokenArb
+  },
+  testnet: {
+    name: WarpChainName10.Arbitrum,
+    displayName: "Arbitrum Sepolia",
+    chainId: "421614",
+    blockTime: 1e3,
+    addressHrp: "0x",
+    defaultApiUrl: "https://sepolia-rollup.arbitrum.io/rpc",
+    logoUrl: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/chains/logos/arbitrum.svg",
+    nativeToken: NativeTokenArb
+  },
+  devnet: {
+    name: WarpChainName10.Arbitrum,
+    displayName: "Arbitrum Sepolia",
+    chainId: "421614",
+    blockTime: 1e3,
+    addressHrp: "0x",
+    defaultApiUrl: "https://sepolia-rollup.arbitrum.io/rpc",
+    logoUrl: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/chains/logos/arbitrum.svg",
+    nativeToken: NativeTokenArb
+  }
+});
+
+// src/chains/base.ts
+import { WarpChainName as WarpChainName11 } from "@joai/warps";
+var NativeTokenBase = {
+  chain: WarpChainName11.Base,
+  identifier: "ETH",
+  name: "Ether",
+  symbol: "ETH",
+  decimals: 18,
+  logoUrl: {
+    light: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/tokens/logos/eth-white.svg",
+    dark: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/tokens/logos/eth-black.svg"
+  }
+};
+var BaseAdapter = createEvmAdapter(WarpChainName11.Base, {
+  mainnet: {
+    name: WarpChainName11.Base,
+    displayName: "Base",
+    chainId: "8453",
+    blockTime: 2e3,
+    addressHrp: "0x",
+    defaultApiUrl: "https://mainnet.base.org",
+    logoUrl: {
+      light: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/chains/logos/base-white.svg",
+      dark: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/chains/logos/base-black.svg"
+    },
+    nativeToken: NativeTokenBase
+  },
+  testnet: {
+    name: WarpChainName11.Base,
+    displayName: "Base Sepolia",
+    chainId: "84532",
+    blockTime: 2e3,
+    addressHrp: "0x",
+    defaultApiUrl: "https://sepolia.base.org",
+    logoUrl: {
+      light: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/chains/logos/base-white.svg",
+      dark: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/chains/logos/base-black.svg"
+    },
+    nativeToken: NativeTokenBase
+  },
+  devnet: {
+    name: WarpChainName11.Base,
+    displayName: "Base Sepolia",
+    chainId: "84532",
+    blockTime: 2e3,
+    addressHrp: "0x",
+    defaultApiUrl: "https://sepolia.base.org",
+    logoUrl: {
+      light: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/chains/logos/base-white.svg",
+      dark: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/chains/logos/base-black.svg"
+    },
+    nativeToken: NativeTokenBase
+  }
+});
+
+// src/chains/combined.ts
+import { WarpChainName as WarpChainName12 } from "@joai/warps";
+var getAllEvmChainNames = () => [
+  WarpChainName12.Ethereum,
+  WarpChainName12.Base,
+  WarpChainName12.Arbitrum,
+  WarpChainName12.Polygon,
+  WarpChainName12.Somnia
+];
+
+// src/chains/ethereum.ts
+import { WarpChainName as WarpChainName13 } from "@joai/warps";
+var NativeTokenEth = {
+  chain: WarpChainName13.Ethereum,
+  identifier: "ETH",
+  symbol: "ETH",
+  name: "Ether",
+  decimals: 18,
+  logoUrl: {
+    light: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/tokens/logos/eth-white.svg",
+    dark: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/tokens/logos/eth-black.svg"
+  }
+};
+var EthereumAdapter = createEvmAdapter(WarpChainName13.Ethereum, {
+  mainnet: {
+    name: WarpChainName13.Ethereum,
+    displayName: "Ethereum Mainnet",
+    chainId: "1",
+    blockTime: 12e3,
+    addressHrp: "0x",
+    defaultApiUrl: "https://ethereum-rpc.publicnode.com",
+    logoUrl: {
+      light: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/chains/logos/ethereum-white.svg",
+      dark: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/chains/logos/ethereum-black.svg"
+    },
+    nativeToken: NativeTokenEth
+  },
+  testnet: {
+    name: WarpChainName13.Ethereum,
+    displayName: "Ethereum Sepolia",
+    chainId: "11155111",
+    blockTime: 12e3,
+    addressHrp: "0x",
+    defaultApiUrl: "https://ethereum-sepolia-rpc.publicnode.com",
+    logoUrl: {
+      light: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/chains/logos/ethereum-white.svg",
+      dark: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/chains/logos/ethereum-black.svg"
+    },
+    nativeToken: NativeTokenEth
+  },
+  devnet: {
+    name: WarpChainName13.Ethereum,
+    displayName: "Ethereum Sepolia",
+    chainId: "11155111",
+    blockTime: 12e3,
+    addressHrp: "0x",
+    defaultApiUrl: "https://ethereum-sepolia-rpc.publicnode.com",
+    logoUrl: {
+      light: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/chains/logos/ethereum-white.svg",
+      dark: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/chains/logos/ethereum-black.svg"
+    },
+    nativeToken: NativeTokenEth
+  }
+});
+
+// src/chains/polygon.ts
+import { WarpChainName as WarpChainName14 } from "@joai/warps";
+var NativeTokenPolygon = {
+  chain: WarpChainName14.Polygon,
+  identifier: "MATIC",
+  symbol: "MATIC",
+  name: "Polygon",
+  decimals: 18,
+  logoUrl: {
+    light: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/tokens/logos/matic-white.svg",
+    dark: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/tokens/logos/matic-black.svg"
+  }
+};
+var PolygonAdapter = createEvmAdapter(WarpChainName14.Polygon, {
+  mainnet: {
+    name: WarpChainName14.Polygon,
+    displayName: "Polygon",
+    chainId: "137",
+    blockTime: 2e3,
+    addressHrp: "0x",
+    defaultApiUrl: "https://polygon-rpc.com",
+    logoUrl: {
+      light: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/chains/logos/polygon-white.svg",
+      dark: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/chains/logos/polygon-black.svg"
+    },
+    nativeToken: NativeTokenPolygon
+  },
+  testnet: {
+    name: WarpChainName14.Polygon,
+    displayName: "Polygon Mumbai",
+    chainId: "80001",
+    blockTime: 2e3,
+    addressHrp: "0x",
+    defaultApiUrl: "https://rpc.ankr.com/polygon_mumbai",
+    logoUrl: {
+      light: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/chains/logos/polygon-white.svg",
+      dark: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/chains/logos/polygon-black.svg"
+    },
+    nativeToken: NativeTokenPolygon
+  },
+  devnet: {
+    name: WarpChainName14.Polygon,
+    displayName: "Polygon Mumbai",
+    chainId: "80001",
+    blockTime: 2e3,
+    addressHrp: "0x",
+    defaultApiUrl: "https://rpc.ankr.com/polygon_mumbai",
+    logoUrl: {
+      light: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/chains/logos/polygon-white.svg",
+      dark: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/chains/logos/polygon-black.svg"
+    },
+    nativeToken: NativeTokenPolygon
+  }
+});
+
+// src/adapters.ts
+import { withAdapterFallback } from "@joai/warps";
+
+// src/chains/somnia.ts
+import { WarpChainName as WarpChainName15 } from "@joai/warps";
+var NativeTokenSomi = {
+  chain: WarpChainName15.Somnia,
+  identifier: "SOMI",
+  symbol: "SOMI",
+  name: "Somnia",
+  decimals: 18,
+  logoUrl: "https://assets.coingecko.com/coins/images/68061/standard/somniacg.png?1754641117"
+};
+var NativeTokenStt = {
+  chain: WarpChainName15.Somnia,
+  identifier: "STT",
+  symbol: "STT",
+  name: "Somnia Testnet Token",
+  decimals: 18,
+  logoUrl: "https://assets.coingecko.com/coins/images/68061/standard/somniacg.png?1754641117"
+};
+var SomniaAdapter = createEvmAdapter(WarpChainName15.Somnia, {
+  mainnet: {
+    name: WarpChainName15.Somnia,
+    displayName: "Somnia Mainnet",
+    chainId: "5031",
+    blockTime: 100,
+    addressHrp: "0x",
+    defaultApiUrl: "https://api.infra.mainnet.somnia.network/",
+    logoUrl: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/chains/logos/somnia.png",
+    nativeToken: NativeTokenSomi
+  },
+  testnet: {
+    name: WarpChainName15.Somnia,
+    displayName: "Somnia Testnet",
+    chainId: "50312",
+    blockTime: 100,
+    addressHrp: "0x",
+    defaultApiUrl: "https://dream-rpc.somnia.network/",
+    logoUrl: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/chains/logos/somnia.png",
+    nativeToken: NativeTokenStt
+  },
+  devnet: {
+    name: WarpChainName15.Somnia,
+    displayName: "Somnia Testnet",
+    chainId: "50312",
+    blockTime: 100,
+    addressHrp: "0x",
+    defaultApiUrl: "https://dream-rpc.somnia.network",
+    logoUrl: "https://raw.githubusercontent.com/JoAiHQ/assets/refs/heads/main/chains/logos/somnia.png",
+    nativeToken: NativeTokenStt
+  }
+});
+
+// src/adapters.ts
+var getAllEvmAdapters = (fallbackFactory) => [
+  withAdapterFallback(EthereumAdapter, fallbackFactory),
+  withAdapterFallback(BaseAdapter, fallbackFactory),
+  withAdapterFallback(ArbitrumAdapter, fallbackFactory),
+  withAdapterFallback(PolygonAdapter, fallbackFactory),
+  withAdapterFallback(SomniaAdapter, fallbackFactory)
+];
+export {
+  ArbitrumAdapter,
+  ArbitrumExplorers,
+  BaseAdapter,
+  BaseExplorers,
+  EthereumAdapter,
+  EthereumExplorers,
+  EvmChainIdMap,
+  EvmChainIds,
+  EvmExplorers,
+  ExplorerUrls,
+  KnownTokens,
+  NativeTokenArb,
+  NativeTokenBase,
+  NativeTokenEth,
+  NativeTokenPolygon,
+  PolygonAdapter,
+  PolygonExplorers,
+  SupportedEvmChainIds,
+  WarpEvmConstants,
+  WarpEvmDataLoader,
+  WarpEvmExecutor,
+  WarpEvmExplorer,
+  WarpEvmOutput,
+  WarpEvmSerializer,
+  WarpEvmWallet,
+  createEvmAdapter,
+  findKnownTokenById,
+  getAllEvmAdapters,
+  getAllEvmChainNames,
+  getKnownTokensForChain
+};
+//# sourceMappingURL=index.mjs.map