@vleap/warps-adapter-evm 0.2.0-alpha.17 → 0.2.0-alpha.19

package/dist/index.mjs

@@ -1,6 +1,178 @@
+// src/chains/arbitrum.ts
+import { WarpChainName } from "@vleap/warps";
+
 // src/WarpEvmDataLoader.ts
-import { getProviderUrl } from "@vleap/warps";
+import {
+  getProviderUrl
+} from "@vleap/warps";
 import { ethers } from "ethers";
+
+// src/LogoService.ts
+var CHAIN_IDS = {
+  ethereum: 1,
+  arbitrum: 42161,
+  base: 8453
+};
+var FALLBACK_LOGOS = {
+  ethereum: {
+    "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": "https://assets.coingecko.com/coins/images/6319/small/USD_Coin_icon.png",
+    "0xdAC17F958D2ee523a2206206994597C13D831ec7": "https://assets.coingecko.com/coins/images/325/small/Tether.png",
+    "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599": "https://assets.coingecko.com/coins/images/7598/small/wrapped_bitcoin_wbtc.png",
+    "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2": "https://assets.coingecko.com/coins/images/2518/small/weth.png",
+    "0x6B175474E89094C44Da98b954EedeAC495271d0F": "https://assets.coingecko.com/coins/images/9956/small/4943.png"
+  },
+  arbitrum: {
+    "0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8": "https://assets.coingecko.com/coins/images/6319/small/USD_Coin_icon.png",
+    "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9": "https://assets.coingecko.com/coins/images/325/small/Tether.png",
+    "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1": "https://assets.coingecko.com/coins/images/2518/small/weth.png"
+  },
+  base: {
+    "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913": "https://assets.coingecko.com/coins/images/6319/small/USD_Coin_icon.png",
+    "0x4200000000000000000000000000000000000006": "https://assets.coingecko.com/coins/images/2518/small/weth.png",
+    "0x036CbD53842c5426634e7929541eC2318f3dCF7e": "https://assets.coingecko.com/coins/images/6319/small/USD_Coin_icon.png",
+    "0x808456652fdb597867f38412077A9182bf77359F": "https://assets.coingecko.com/coins/images/3318/small/euro-coin.png",
+    "0xcbB7C0006F23900c38EB856149F799620fcb8A4a": "https://assets.coingecko.com/coins/images/7598/small/wrapped_bitcoin_wbtc.png"
+  }
+};
+var TOKEN_LISTS = [
+  "https://tokens.uniswap.org",
+  "https://raw.githubusercontent.com/compound-finance/token-list/master/compound.tokenlist.json",
+  "https://tokens.1inch.io"
+];
+var logoCache = /* @__PURE__ */ new Map();
+var tokenInfoCache = /* @__PURE__ */ new Map();
+var tokenListCache = /* @__PURE__ */ new Map();
+var EvmLogoService = class {
+  static async getTokenInfo(chainName, tokenAddress) {
+    const cacheKey = `${chainName}:${tokenAddress.toLowerCase()}`;
+    if (tokenInfoCache.has(cacheKey)) {
+      return tokenInfoCache.get(cacheKey);
+    }
+    let tokenInfo = {};
+    try {
+      tokenInfo = await this.fetchFromTokenLists(chainName, tokenAddress);
+    } catch (error) {
+    }
+    if (!tokenInfo.logoURI) {
+      try {
+        tokenInfo = { ...tokenInfo, ...await this.fetchFromDefiLlama(chainName, tokenAddress) };
+      } catch (error) {
+      }
+    }
+    tokenInfoCache.set(cacheKey, tokenInfo);
+    return tokenInfo;
+  }
+  static async getLogoUrl(chainName, tokenAddress, tokenName, tokenSymbol) {
+    const cacheKey = `${chainName}:${tokenAddress.toLowerCase()}`;
+    if (logoCache.has(cacheKey)) {
+      return logoCache.get(cacheKey);
+    }
+    let logoUrl = "";
+    const fallbackLogos = FALLBACK_LOGOS[chainName];
+    if (fallbackLogos && fallbackLogos[tokenAddress]) {
+      logoUrl = fallbackLogos[tokenAddress];
+    } else {
+      const tokenInfo = await this.getTokenInfo(chainName, tokenAddress);
+      logoUrl = tokenInfo.logoURI || "";
+      if (!logoUrl && (tokenSymbol || tokenName)) {
+        try {
+          logoUrl = await this.fetchFromTrustWallet(chainName, tokenAddress);
+        } catch (error) {
+        }
+      }
+    }
+    logoCache.set(cacheKey, logoUrl);
+    return logoUrl;
+  }
+  static async fetchFromTokenLists(chainName, tokenAddress) {
+    const chainId = CHAIN_IDS[chainName];
+    if (!chainId) return {};
+    const normalizedAddress = tokenAddress.toLowerCase();
+    if (tokenListCache.has(`${chainId}:${normalizedAddress}`)) {
+      return tokenListCache.get(`${chainId}:${normalizedAddress}`) || {};
+    }
+    for (const tokenListUrl of TOKEN_LISTS) {
+      try {
+        const response = await fetch(tokenListUrl, {
+          headers: { Accept: "application/json" },
+          signal: AbortSignal.timeout(5e3)
+        });
+        if (response.ok) {
+          const data = await response.json();
+          const token = data.tokens.find((t) => t.chainId === chainId && t.address.toLowerCase() === normalizedAddress);
+          if (token) {
+            const tokenInfo = {
+              name: token.name,
+              symbol: token.symbol,
+              decimals: token.decimals,
+              logoURI: token.logoURI
+            };
+            tokenListCache.set(`${chainId}:${normalizedAddress}`, tokenInfo);
+            return tokenInfo;
+          }
+        }
+      } catch (error) {
+        continue;
+      }
+    }
+    return {};
+  }
+  static async fetchFromDefiLlama(chainName, tokenAddress) {
+    try {
+      const chainMapping = {
+        ethereum: "ethereum",
+        arbitrum: "arbitrum",
+        base: "base"
+      };
+      const chain = chainMapping[chainName];
+      if (!chain) return {};
+      const response = await fetch(`https://coins.llama.fi/prices/current/${chain}:${tokenAddress}`, { signal: AbortSignal.timeout(5e3) });
+      if (response.ok) {
+        const data = await response.json();
+        const coinData = data.coins?.[`${chain}:${tokenAddress}`];
+        if (coinData) {
+          return {
+            symbol: coinData.symbol,
+            logoURI: coinData.logoURI
+          };
+        }
+      }
+    } catch (error) {
+    }
+    return {};
+  }
+  static async fetchFromTrustWallet(chainName, tokenAddress) {
+    try {
+      const chainMapping = {
+        ethereum: "ethereum",
+        arbitrum: "arbitrum",
+        base: "base"
+      };
+      const chain = chainMapping[chainName];
+      if (!chain) return "";
+      const logoUrl = `https://raw.githubusercontent.com/trustwallet/assets/master/blockchains/${chain}/assets/${tokenAddress}/logo.png`;
+      const response = await fetch(logoUrl, {
+        method: "HEAD",
+        signal: AbortSignal.timeout(3e3)
+      });
+      if (response.ok) {
+        return logoUrl;
+      }
+    } catch (error) {
+    }
+    return "";
+  }
+  static clearCache() {
+    logoCache.clear();
+    tokenInfoCache.clear();
+    tokenListCache.clear();
+  }
+  static getCacheSize() {
+    return logoCache.size + tokenInfoCache.size + tokenListCache.size;
+  }
+};
+
+// src/WarpEvmDataLoader.ts
 var ERC20_ABI = [
   "function balanceOf(address owner) view returns (uint256)",
   "function decimals() view returns (uint8)",
@@ -39,6 +211,25 @@ var KNOWN_TOKENS = {
       symbol: "DAI",
       decimals: 18,
       logoUrl: "https://assets.coingecko.com/coins/images/9956/small/4943.png"
+    },
+    // Sepolia testnet tokens
+    "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238": {
+      name: "USD Coin",
+      symbol: "USDC",
+      decimals: 6,
+      logoUrl: "https://assets.coingecko.com/coins/images/6319/small/USD_Coin_icon.png"
+    },
+    "0x7169D38820dfd117C3FA1f22a697dBA58d90BA06": {
+      name: "Tether USD",
+      symbol: "USDT",
+      decimals: 6,
+      logoUrl: "https://assets.coingecko.com/coins/images/325/small/Tether.png"
+    },
+    "0x7b79995e5f793A07Bc00c21412e50Ecae098E7f9": {
+      name: "Wrapped Ether",
+      symbol: "WETH",
+      decimals: 18,
+      logoUrl: "https://assets.coingecko.com/coins/images/2518/small/weth.png"
     }
   },
   arbitrum: {
@@ -73,6 +264,24 @@ var KNOWN_TOKENS = {
       symbol: "WETH",
       decimals: 18,
       logoUrl: "https://assets.coingecko.com/coins/images/2518/small/weth.png"
+    },
+    "0x036CbD53842c5426634e7929541eC2318f3dCF7e": {
+      name: "USD Coin",
+      symbol: "USDC",
+      decimals: 6,
+      logoUrl: "https://assets.coingecko.com/coins/images/6319/small/USD_Coin_icon.png"
+    },
+    "0x808456652fdb597867f38412077A9182bf77359F": {
+      name: "Euro Coin",
+      symbol: "EURC",
+      decimals: 6,
+      logoUrl: "https://assets.coingecko.com/coins/images/3318/small/euro-coin.png"
+    },
+    "0xcbB7C0006F23900c38EB856149F799620fcb8A4a": {
+      name: "Coinbase Wrapped BTC",
+      symbol: "CBETH",
+      decimals: 8,
+      logoUrl: "https://assets.coingecko.com/coins/images/7598/small/wrapped_bitcoin_wbtc.png"
     }
   }
 };
@@ -81,12 +290,14 @@ var WarpEvmDataLoader = class {
     this.config = config;
     this.chain = chain;
     const apiUrl = getProviderUrl(this.config, this.chain.name, this.config.env, this.chain.defaultApiUrl);
-    this.provider = new ethers.JsonRpcProvider(apiUrl);
+    const network = new ethers.Network(this.chain.name, parseInt(this.chain.chainId));
+    this.provider = new ethers.JsonRpcProvider(apiUrl, network);
   }
   async getAccount(address) {
     try {
       const balance = await this.provider.getBalance(address);
       return {
+        chain: this.chain.name,
         address,
         balance
       };
@@ -100,12 +311,19 @@ var WarpEvmDataLoader = class {
       const tokenBalances = await this.getERC20TokenBalances(address);
       for (const tokenBalance of tokenBalances) {
         if (tokenBalance.balance > 0n) {
+          const logoUrl = tokenBalance.metadata.logoUrl || await EvmLogoService.getLogoUrl(
+            this.chain.name,
+            tokenBalance.tokenAddress,
+            tokenBalance.metadata.name,
+            tokenBalance.metadata.symbol
+          );
           assets.push({
+            chain: this.chain.name,
             identifier: tokenBalance.tokenAddress,
             name: tokenBalance.metadata.name,
             amount: tokenBalance.balance,
             decimals: tokenBalance.metadata.decimals,
-            logoUrl: tokenBalance.metadata.logoUrl || ""
+            logoUrl: logoUrl || ""
           });
         }
       }
@@ -114,6 +332,9 @@ var WarpEvmDataLoader = class {
       throw new Error(`Failed to get account assets for ${address}: ${error}`);
     }
   }
+  async getAccountActions(address, options) {
+    return [];
+  }
   async getERC20TokenBalances(address) {
     const tokenBalances = [];
     const knownTokens = KNOWN_TOKENS[this.chain.name] || {};
@@ -128,7 +349,6 @@ var WarpEvmDataLoader = class {
           });
         }
       } catch (error) {
-        console.warn(`Failed to get balance for token ${tokenAddress}: ${error}`);
       }
     }
     const additionalTokens = await this.detectTokensFromEvents(address);
@@ -145,7 +365,6 @@ var WarpEvmDataLoader = class {
             });
           }
         } catch (error) {
-          console.warn(`Failed to get metadata/balance for detected token ${tokenAddress}: ${error}`);
         }
       }
     }
@@ -162,12 +381,26 @@ var WarpEvmDataLoader = class {
   }
   async getTokenMetadata(tokenAddress) {
     try {
+      const tokenInfo = await EvmLogoService.getTokenInfo(this.chain.name, tokenAddress);
+      if (tokenInfo.name && tokenInfo.symbol && tokenInfo.decimals !== void 0) {
+        return {
+          name: tokenInfo.name,
+          symbol: tokenInfo.symbol,
+          decimals: tokenInfo.decimals,
+          logoUrl: tokenInfo.logoURI
+        };
+      }
       const contract = new ethers.Contract(tokenAddress, ERC20_ABI, this.provider);
-      const [name, symbol, decimals] = await Promise.all([contract.name(), contract.symbol(), contract.decimals()]);
+      const [name, symbol, decimals] = await Promise.all([
+        contract.name().catch(() => tokenInfo.name || "Unknown Token"),
+        contract.symbol().catch(() => tokenInfo.symbol || "UNKNOWN"),
+        contract.decimals().catch(() => tokenInfo.decimals || 18)
+      ]);
       return {
-        name: name || "Unknown Token",
-        symbol: symbol || "UNKNOWN",
-        decimals: decimals || 18
+        name: name || tokenInfo.name || "Unknown Token",
+        symbol: symbol || tokenInfo.symbol || "UNKNOWN",
+        decimals: decimals || tokenInfo.decimals || 18,
+        logoUrl: tokenInfo.logoURI
       };
     } catch (error) {
       throw new Error(`Failed to get token metadata: ${error}`);
@@ -195,7 +428,6 @@ var WarpEvmDataLoader = class {
       }
       return Array.from(tokenAddresses);
     } catch (error) {
-      console.warn(`Failed to detect tokens from events: ${error}`);
       return [];
     }
   }
@@ -204,7 +436,6 @@ var WarpEvmDataLoader = class {
     try {
       return await this.getTokenMetadata(tokenAddress);
     } catch (error) {
-      console.warn(`Failed to get token info for ${tokenAddress}: ${error}`);
       return null;
     }
   }
@@ -223,23 +454,44 @@ var WarpEvmDataLoader = class {
           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;
   }
+  async getAccountTokens(address) {
+    return this.getAccountAssets(address);
+  }
+  async getTokenMetadataPublic(tokenAddress) {
+    try {
+      return await this.getTokenMetadata(tokenAddress);
+    } catch (error) {
+      return null;
+    }
+  }
+  async getChainInfo() {
+    try {
+      const network = await this.provider.getNetwork();
+      const latestBlock = await this.provider.getBlock("latest");
+      return {
+        chainId: network.chainId.toString(),
+        blockTime: latestBlock?.timestamp ? Date.now() / 1e3 - latestBlock.timestamp : 12
+      };
+    } catch (error) {
+      throw new Error(`Failed to get chain info: ${error}`);
+    }
+  }
 };
 
 // src/WarpEvmExecutor.ts
 import {
   applyResultsToMessages,
   getNextInfo,
-  getProviderUrl as getProviderUrl2,
+  getProviderUrl as getProviderUrl3,
   getWarpActionByIndex
 } from "@vleap/warps";
-import { ethers as ethers3 } from "ethers";
+import { ethers as ethers4 } from "ethers";
 
 // src/constants.ts
 var WarpEvmConstants = {
@@ -248,6 +500,8 @@ var WarpEvmConstants = {
     ContractCall: 1e5,
     ContractDeploy: 5e5,
     Transfer: 21e3,
+    TokenTransfer: 65e3,
+    // ERC-20 transfer gas limit
     Approve: 46e3,
     Swap: 2e5
   },
@@ -317,9 +571,11 @@ var ExplorerUrls = {
 // src/WarpEvmResults.ts
 import {
   evaluateResultsCommon,
+  getProviderUrl as getProviderUrl2,
   parseResultsOutIndex,
   WarpConstants as WarpConstants2
 } from "@vleap/warps";
+import { ethers as ethers3 } from "ethers";
 
 // src/WarpEvmSerializer.ts
 import {
@@ -478,9 +734,19 @@ var WarpEvmSerializer = class {
 
 // src/WarpEvmResults.ts
 var WarpEvmResults = class {
-  constructor(config) {
+  constructor(config, chain) {
     this.config = config;
+    this.chain = chain;
     this.serializer = new WarpEvmSerializer();
+    if (this.chain) {
+      const apiUrl = getProviderUrl2(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(apiUrl, network);
+    } else {
+      const apiUrl = getProviderUrl2(this.config, "ethereum", this.config.env, "https://ethereum-rpc.publicnode.com");
+      const network = new ethers3.Network("ethereum", 1);
+      this.provider = new ethers3.JsonRpcProvider(apiUrl, network);
+    }
   }
   async getTransactionExecutionResults(warp, tx) {
     const success = tx.status === 1;
@@ -505,6 +771,7 @@ var WarpEvmResults = class {
       tx,
       next: null,
       values: [transactionHash, blockNumber, gasUsed, gasPrice, ...logs.length > 0 ? logs : []],
+      valuesRaw: [transactionHash, blockNumber, gasUsed, gasPrice, ...logs.length > 0 ? logs : []],
       results: {},
       messages: {}
     };
@@ -513,7 +780,7 @@ var WarpEvmResults = class {
     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 };
+    if (!warp.results) return { values, valuesRaw, results };
     const getNestedValue = (path) => {
       const indices = path.split(".").slice(1).map((i) => parseInt(i) - 1);
       if (indices.length === 0) return void 0;
@@ -537,7 +804,29 @@ var WarpEvmResults = class {
         results[key] = path;
       }
     }
-    return { values, results: await evaluateResultsCommon(warp, results, actionIndex, inputs) };
+    return { values, valuesRaw, results: await evaluateResultsCommon(warp, results, actionIndex, inputs) };
+  }
+  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;
+    }
   }
 };
 
@@ -547,9 +836,10 @@ var WarpEvmExecutor = class {
     this.config = config;
     this.chain = chain;
     this.serializer = new WarpEvmSerializer();
-    const apiUrl = getProviderUrl2(this.config, chain.name, this.config.env, this.chain.defaultApiUrl);
-    this.provider = new ethers3.JsonRpcProvider(apiUrl);
-    this.results = new WarpEvmResults(config);
+    const apiUrl = getProviderUrl3(this.config, chain.name, this.config.env, this.chain.defaultApiUrl);
+    const network = new ethers4.Network(this.chain.name, parseInt(this.chain.chainId));
+    this.provider = new ethers4.JsonRpcProvider(apiUrl, network);
+    this.results = new WarpEvmResults(config, this.chain);
   }
   async createTransaction(executable) {
     const action = getWarpActionByIndex(executable.warp, executable.action);
@@ -569,11 +859,11 @@ var WarpEvmExecutor = class {
   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)) {
+    if (!ethers4.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}`);
+    if (executable.transfers && executable.transfers.length > 0) {
+      return this.createTokenTransferTransaction(executable, userWallet);
     }
     const tx = {
       to: executable.destination,
@@ -589,14 +879,11 @@ var WarpEvmExecutor = class {
     if (!action || !("func" in action) || !action.func) {
       throw new Error("WarpEvmExecutor: Contract action must have a function name");
     }
-    if (!ethers3.isAddress(executable.destination)) {
+    if (!ethers4.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 iface = new ethers4.Interface([`function ${action.func}`]);
       const encodedData = iface.encodeFunctionData(action.func, executable.args);
       const tx = {
         to: executable.destination,
@@ -608,6 +895,50 @@ var WarpEvmExecutor = class {
       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 (!ethers4.isAddress(transfer.identifier)) {
+      throw new Error(`WarpEvmExecutor: Invalid token address: ${transfer.identifier}`);
+    }
+    const transferInterface = new ethers4.Interface(["function transfer(address to, uint256 amount) returns (bool)"]);
+    const encodedData = transferInterface.encodeFunctionData("transfer", [executable.destination, transfer.amount]);
+    const tx = {
+      to: transfer.identifier,
+      // Token contract address
+      value: 0n,
+      // No native token value for ERC-20 transfers
+      data: encodedData
+    };
+    return this.estimateGasAndSetDefaults(tx, userWallet);
+  }
   async executeQuery(executable) {
     const action = getWarpActionByIndex(executable.warp, executable.action);
     if (action.type !== "query") {
@@ -616,11 +947,11 @@ var WarpEvmExecutor = class {
     if (!action.func) {
       throw new Error("WarpEvmExecutor: Query action must have a function name");
     }
-    if (!ethers3.isAddress(executable.destination)) {
+    if (!ethers4.isAddress(executable.destination)) {
       throw new Error(`WarpEvmExecutor: Invalid contract address for query: ${executable.destination}`);
     }
     try {
-      const iface = new ethers3.Interface([`function ${action.func}`]);
+      const iface = new ethers4.Interface([`function ${action.func}`]);
       const encodedData = iface.encodeFunctionData(action.func, executable.args);
       const result = await this.provider.call({
         to: executable.destination,
@@ -628,7 +959,7 @@ var WarpEvmExecutor = class {
       });
       const decodedResult = iface.decodeFunctionResult(action.func, result);
       const isSuccess = true;
-      const { values, results } = await this.results.extractQueryResults(
+      const { values, valuesRaw, results } = await this.results.extractQueryResults(
         executable.warp,
         decodedResult,
         executable.action,
@@ -644,6 +975,7 @@ var WarpEvmExecutor = class {
         tx: null,
         next,
         values,
+        valuesRaw,
         results,
         messages: applyResultsToMessages(executable.warp, results)
       };
@@ -657,37 +989,14 @@ var WarpEvmExecutor = class {
         tx: null,
         next: null,
         values: [],
+        valuesRaw: [],
         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);
-    }
+    return input;
   }
   async estimateGasAndSetDefaults(tx, from) {
     try {
@@ -705,6 +1014,7 @@ var WarpEvmExecutor = class {
       if (feeData.maxFeePerGas && feeData.maxPriorityFeePerGas) {
         return {
           ...tx,
+          chainId: BigInt(this.chain.chainId),
           gasLimit: gasEstimate,
           maxFeePerGas: feeData.maxFeePerGas,
           maxPriorityFeePerGas: feeData.maxPriorityFeePerGas
@@ -712,32 +1022,53 @@ var WarpEvmExecutor = class {
       } else if (feeData.gasPrice) {
         return {
           ...tx,
+          chainId: BigInt(this.chain.chainId),
           gasLimit: gasEstimate,
           gasPrice: feeData.gasPrice
         };
       } else {
         return {
           ...tx,
+          chainId: BigInt(this.chain.chainId),
           gasLimit: gasEstimate,
-          gasPrice: ethers3.parseUnits(WarpEvmConstants.GasPrice.Default, "wei")
+          gasPrice: ethers4.parseUnits(WarpEvmConstants.GasPrice.Default, "wei")
         };
       }
     } catch (error) {
       let defaultGasLimit = BigInt(WarpEvmConstants.GasLimit.Default);
       if (tx.data && tx.data !== "0x") {
-        defaultGasLimit = BigInt(WarpEvmConstants.GasLimit.ContractCall);
+        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: BigInt(this.chain.chainId),
         gasLimit: defaultGasLimit,
-        gasPrice: ethers3.parseUnits(WarpEvmConstants.GasPrice.Default, "wei")
+        gasPrice: ethers4.parseUnits(WarpEvmConstants.GasPrice.Default, "wei")
       };
     }
   }
   async signMessage(message, privateKey) {
-    throw new Error("Not implemented");
+    try {
+      const wallet = new ethers4.Wallet(privateKey);
+      const signature = await wallet.signMessage(message);
+      return signature;
+    } catch (error) {
+      throw new Error(`Failed to sign message: ${error}`);
+    }
+  }
+  async verifyMessage(message, signature) {
+    try {
+      const recoveredAddress = ethers4.verifyMessage(message, signature);
+      return recoveredAddress;
+    } catch (error) {
+      throw new Error(`Failed to verify message: ${error}`);
+    }
   }
 };
 
@@ -825,6 +1156,39 @@ var WarpEvmExplorer = class {
     });
     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/chains/common.ts
@@ -837,7 +1201,7 @@ var createEvmAdapter = (chainName, chainPrefix, chainInfos) => {
       prefix: chainPrefix,
       builder: () => fallback.builder(),
       executor: new WarpEvmExecutor(config, chainInfos[config.env]),
-      results: new WarpEvmResults(config),
+      results: new WarpEvmResults(config, chainInfos[config.env]),
       serializer: new WarpEvmSerializer(),
       registry: fallback.registry,
       explorer: new WarpEvmExplorer(chainInfos[config.env], config),
@@ -849,54 +1213,55 @@ var createEvmAdapter = (chainName, chainPrefix, chainInfos) => {
 };
 
 // src/chains/arbitrum.ts
-var ChainNameArbitrum = "arbitrum";
 var NativeTokenArb = {
+  chain: WarpChainName.Arbitrum,
   identifier: "ARB",
   name: "ARB",
   decimals: 18,
   logoUrl: "https://vleap.ai/images/tokens/arb.svg"
 };
-var getArbitrumAdapter = createEvmAdapter(ChainNameArbitrum, "arb", {
-  devnet: {
-    name: ChainNameArbitrum,
-    displayName: "Arbitrum Devnet",
-    chainId: "421614",
+var getArbitrumAdapter = createEvmAdapter(WarpChainName.Arbitrum, "arb", {
+  mainnet: {
+    name: WarpChainName.Arbitrum,
+    displayName: "Arbitrum",
+    chainId: "42161",
     blockTime: 1e3,
     addressHrp: "0x",
-    defaultApiUrl: "https://sepolia-rollup.arbitrum.io/rpc",
+    defaultApiUrl: "https://arb1.arbitrum.io/rpc",
     nativeToken: NativeTokenArb
   },
   testnet: {
-    name: ChainNameArbitrum,
-    displayName: "Arbitrum Testnet",
-    chainId: "421613",
+    name: WarpChainName.Arbitrum,
+    displayName: "Arbitrum Sepolia",
+    chainId: "421614",
     blockTime: 1e3,
     addressHrp: "0x",
-    defaultApiUrl: "https://goerli-rollup.arbitrum.io/rpc",
+    defaultApiUrl: "https://sepolia-rollup.arbitrum.io/rpc",
     nativeToken: NativeTokenArb
   },
-  mainnet: {
-    name: ChainNameArbitrum,
-    displayName: "Arbitrum",
-    chainId: "42161",
+  devnet: {
+    name: WarpChainName.Arbitrum,
+    displayName: "Arbitrum Sepolia",
+    chainId: "421614",
     blockTime: 1e3,
     addressHrp: "0x",
-    defaultApiUrl: "https://arb1.arbitrum.io/rpc",
+    defaultApiUrl: "https://sepolia-rollup.arbitrum.io/rpc",
     nativeToken: NativeTokenArb
   }
 });
 
 // src/chains/base.ts
-var ChainNameBase = "base";
+import { WarpChainName as WarpChainName2 } from "@vleap/warps";
 var NativeTokenBase = {
+  chain: WarpChainName2.Base,
   identifier: "ETH",
   name: "ETH",
   decimals: 18,
   logoUrl: "https://vleap.ai/images/tokens/eth.svg"
 };
-var getBaseAdapter = createEvmAdapter(ChainNameBase, "base", {
+var getBaseAdapter = createEvmAdapter(WarpChainName2.Base, "base", {
   mainnet: {
-    name: ChainNameBase,
+    name: WarpChainName2.Base,
     displayName: "Base",
     chainId: "8453",
     blockTime: 2e3,
@@ -905,17 +1270,17 @@ var getBaseAdapter = createEvmAdapter(ChainNameBase, "base", {
     nativeToken: NativeTokenBase
   },
   testnet: {
-    name: ChainNameBase,
-    displayName: "Base Testnet",
-    chainId: "84531",
+    name: WarpChainName2.Base,
+    displayName: "Base Sepolia",
+    chainId: "84532",
     blockTime: 2e3,
     addressHrp: "0x",
-    defaultApiUrl: "https://goerli.base.org",
+    defaultApiUrl: "https://sepolia.base.org",
     nativeToken: NativeTokenBase
   },
   devnet: {
-    name: ChainNameBase,
-    displayName: "Base Devnet",
+    name: WarpChainName2.Base,
+    displayName: "Base Sepolia",
     chainId: "84532",
     blockTime: 2e3,
     addressHrp: "0x",
@@ -924,40 +1289,44 @@ var getBaseAdapter = createEvmAdapter(ChainNameBase, "base", {
   }
 });
 
+// src/chains/combined.ts
+import { WarpChainName as WarpChainName4 } from "@vleap/warps";
+
 // src/chains/ethereum.ts
-var ChainNameEthereum = "ethereum";
+import { WarpChainName as WarpChainName3 } from "@vleap/warps";
 var NativeTokenEth = {
+  chain: WarpChainName3.Ethereum,
   identifier: "ETH",
   name: "ETH",
   decimals: 18,
   logoUrl: "https://vleap.ai/images/tokens/eth.svg"
 };
-var getEthereumAdapter = createEvmAdapter(ChainNameEthereum, "eth", {
-  devnet: {
-    name: ChainNameEthereum,
-    displayName: "Ethereum Devnet",
-    chainId: "11155111",
+var getEthereumAdapter = createEvmAdapter(WarpChainName3.Ethereum, "eth", {
+  mainnet: {
+    name: WarpChainName3.Ethereum,
+    displayName: "Ethereum Mainnet",
+    chainId: "1",
     blockTime: 12e3,
     addressHrp: "0x",
-    defaultApiUrl: "https://ethereum-sepolia-rpc.publicnode.com",
+    defaultApiUrl: "https://ethereum-rpc.publicnode.com",
     nativeToken: NativeTokenEth
   },
   testnet: {
-    name: ChainNameEthereum,
-    displayName: "Ethereum Testnet",
+    name: WarpChainName3.Ethereum,
+    displayName: "Ethereum Sepolia",
     chainId: "11155111",
     blockTime: 12e3,
     addressHrp: "0x",
     defaultApiUrl: "https://ethereum-sepolia-rpc.publicnode.com",
     nativeToken: NativeTokenEth
   },
-  mainnet: {
-    name: ChainNameEthereum,
-    displayName: "Ethereum Mainnet",
-    chainId: "1",
+  devnet: {
+    name: WarpChainName3.Ethereum,
+    displayName: "Ethereum Sepolia",
+    chainId: "11155111",
     blockTime: 12e3,
     addressHrp: "0x",
-    defaultApiUrl: "https://ethereum-rpc.publicnode.com",
+    defaultApiUrl: "https://ethereum-sepolia-rpc.publicnode.com",
     nativeToken: NativeTokenEth
   }
 });
@@ -968,24 +1337,24 @@ var getAllEvmAdapters = (config, fallback) => [
   getArbitrumAdapter(config, fallback),
   getBaseAdapter(config, fallback)
 ];
-var getAllEvmChainNames = () => [ChainNameArbitrum, ChainNameBase, ChainNameEthereum];
+var getAllEvmChainNames = () => [WarpChainName4.Ethereum, WarpChainName4.Base, WarpChainName4.Arbitrum];
 export {
   ArbitrumExplorers,
   BaseExplorers,
-  ChainNameArbitrum,
-  ChainNameBase,
-  ChainNameEthereum,
   EthereumExplorers,
   EvmExplorers,
+  EvmLogoService,
   ExplorerUrls,
   NativeTokenArb,
   NativeTokenBase,
   NativeTokenEth,
   WarpEvmConstants,
+  WarpEvmDataLoader,
   WarpEvmExecutor,
   WarpEvmExplorer,
   WarpEvmResults,
   WarpEvmSerializer,
+  createEvmAdapter,
   getAllEvmAdapters,
   getAllEvmChainNames,
   getArbitrumAdapter,