@vleap/warps-adapter-evm 0.2.0-alpha.8 → 0.2.0-beta.43

package/dist/index.mjs

@@ -1,203 +1,300 @@
-// src/WarpEvmBuilder.ts
+// src/chains/arbitrum.ts
+import { WarpChainName as WarpChainName6 } from "@vleap/warps";
+
+// src/WarpEvmDataLoader.ts
+import {
+  CacheTtl as CacheTtl2,
+  getProviderConfig,
+  WarpCache as WarpCache2,
+  WarpCacheKey
+} from "@vleap/warps";
 import { ethers } from "ethers";
 
-// src/config.ts
-var EVM_CHAIN_CONFIGS = {
-  ethereum: {
-    mainnet: {
-      apiUrl: "https://eth-mainnet.g.alchemy.com/v2/demo",
-      explorerUrl: "https://etherscan.io",
-      chainId: "1",
-      registryAddress: "0x0000000000000000000000000000000000000000",
-      nativeToken: "ETH",
-      blockTime: 12e3
-    },
-    testnet: {
-      apiUrl: "https://eth-sepolia.g.alchemy.com/v2/demo",
-      explorerUrl: "https://sepolia.etherscan.io",
-      chainId: "11155111",
-      registryAddress: "0x0000000000000000000000000000000000000000",
-      nativeToken: "ETH",
-      blockTime: 12e3
-    },
-    devnet: {
-      apiUrl: "http://localhost:8545",
-      explorerUrl: "http://localhost:4000",
-      chainId: "1337",
-      registryAddress: "0x0000000000000000000000000000000000000000",
-      nativeToken: "ETH",
-      blockTime: 12e3
-    }
-  },
-  arbitrum: {
-    mainnet: {
-      apiUrl: "https://arb-mainnet.g.alchemy.com/v2/demo",
-      explorerUrl: "https://arbiscan.io",
-      chainId: "42161",
-      registryAddress: "0x0000000000000000000000000000000000000000",
-      nativeToken: "ETH",
-      blockTime: 1e3
-    },
-    testnet: {
-      apiUrl: "https://arb-sepolia.g.alchemy.com/v2/demo",
-      explorerUrl: "https://sepolia.arbiscan.io",
-      chainId: "421614",
-      registryAddress: "0x0000000000000000000000000000000000000000",
-      nativeToken: "ETH",
-      blockTime: 1e3
-    },
-    devnet: {
-      apiUrl: "http://localhost:8545",
-      explorerUrl: "http://localhost:4000",
-      chainId: "1337",
-      registryAddress: "0x0000000000000000000000000000000000000000",
-      nativeToken: "ETH",
-      blockTime: 1e3
-    }
-  },
-  base: {
-    mainnet: {
-      apiUrl: "https://mainnet.base.org",
-      explorerUrl: "https://basescan.org",
-      chainId: "8453",
-      registryAddress: "0x0000000000000000000000000000000000000000",
-      nativeToken: "ETH",
-      blockTime: 2e3
-    },
-    testnet: {
-      apiUrl: "https://sepolia.base.org",
-      explorerUrl: "https://sepolia.basescan.org",
-      chainId: "84532",
-      registryAddress: "0x0000000000000000000000000000000000000000",
-      nativeToken: "ETH",
-      blockTime: 2e3
-    },
-    devnet: {
-      apiUrl: "http://localhost:8545",
-      explorerUrl: "http://localhost:4000",
-      chainId: "1337",
-      registryAddress: "0x0000000000000000000000000000000000000000",
-      nativeToken: "ETH",
-      blockTime: 2e3
-    }
-  }
-};
-var DEFAULT_CHAIN = "ethereum";
-var getEvmChainConfig = (chain = DEFAULT_CHAIN, env) => {
-  const chainConfigs = EVM_CHAIN_CONFIGS[chain];
-  if (!chainConfigs) {
-    throw new Error(`Unsupported EVM chain: ${chain}`);
-  }
-  const config = chainConfigs[env];
-  if (!config) {
-    throw new Error(`Unsupported environment ${env} for chain ${chain}`);
+// src/providers/UniswapService.ts
+import { CacheTtl } from "@vleap/warps";
+var _UniswapService = class _UniswapService {
+  constructor(cache, chainId) {
+    this.cache = cache;
+    this.chainId = chainId;
   }
-  return config;
-};
-var getEvmApiUrl = (env, chain = DEFAULT_CHAIN) => {
-  return getEvmChainConfig(chain, env).apiUrl;
-};
-var getEvmExplorerUrl = (env, chain = DEFAULT_CHAIN) => {
-  return getEvmChainConfig(chain, env).explorerUrl;
-};
-
-// src/WarpEvmBuilder.ts
-var WarpEvmBuilder = class {
-  constructor(config) {
-    this.config = config;
-    this.warp = {};
-    this.actions = [];
-  }
-  async createFromRaw(encoded) {
+  async getTokenList() {
     try {
-      const decoded = JSON.parse(encoded);
-      return decoded;
+      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 decode warp from raw data: ${error}`);
-    }
-  }
-  setTitle(title) {
-    this.warp.title = title;
-    return this;
-  }
-  setDescription(description) {
-    this.warp.description = description;
-    return this;
-  }
-  setPreview(preview) {
-    this.warp.preview = preview;
-    return this;
-  }
-  setActions(actions) {
-    this.actions = actions;
-    return this;
-  }
-  addAction(action) {
-    this.actions.push(action);
-    return this;
-  }
-  async build() {
-    if (!this.warp.title) {
-      throw new Error("Warp title is required");
+      throw new Error(`Failed to fetch Uniswap token list: ${error}`);
     }
-    return {
-      protocol: "warp",
-      name: this.warp.name || "evm-warp",
-      title: this.warp.title,
-      description: this.warp.description || null,
-      preview: this.warp.preview || null,
-      actions: this.actions,
-      meta: {
-        chain: "evm",
-        hash: ethers.keccak256(ethers.toUtf8Bytes(this.warp.title)),
-        creator: this.config.user?.wallets?.evm || "",
-        createdAt: (/* @__PURE__ */ new Date()).toISOString()
-      }
-    };
-  }
-  createInscriptionTransaction(warp) {
-    const warpData = JSON.stringify(warp);
-    const data = ethers.toUtf8Bytes(warpData);
-    return {
-      data: ethers.hexlify(data)
-    };
   }
-  async createFromTransaction(tx, validate) {
-    if (!tx.data || tx.data === "0x") {
-      throw new Error("Transaction has no data");
+  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 data = ethers.toUtf8String(tx.data);
-      const warp = JSON.parse(data);
-      if (validate) {
-        if (!warp.protocol || warp.protocol !== "warp") {
-          throw new Error("Invalid warp protocol");
-        }
-        if (!warp.title) {
-          throw new Error("Warp title is required");
-        }
+      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 warp;
+      return token;
     } catch (error) {
-      throw new Error(`Failed to create warp from transaction: ${error}`);
+      return null;
     }
   }
-  async createFromTransactionHash(hash, cache) {
-    try {
-      const provider = new ethers.JsonRpcProvider(getEvmApiUrl(this.config.env));
-      const tx = await provider.getTransaction(hash);
-      if (!tx) {
-        return null;
-      }
-      return await this.createFromTransaction(tx);
-    } catch (error) {
+  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/tokens/arbitrum.ts
+import { WarpChainName } from "@vleap/warps";
+var ArbitrumChain = WarpChainName.Arbitrum;
+var ArbitrumTokens = [
+  {
+    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/base.ts
+import { WarpChainName as WarpChainName2 } from "@vleap/warps";
+var BaseChain = WarpChainName2.Base;
+var BaseTokens = [
+  {
+    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 WarpChainName3 } from "@vleap/warps";
+var BaseChain2 = WarpChainName3.Base;
+var BaseSepoliaTokens = [
+  {
+    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 WarpChainName4 } from "@vleap/warps";
+var EthereumChain = WarpChainName4.Ethereum;
+var EthereumTokens = [
+  {
+    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 WarpChainName5 } from "@vleap/warps";
+var EthereumChain2 = WarpChainName5.Ethereum;
+var EthereumSepoliaTokens = [
+  {
+    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: "0x7b79995e5f793A07Bc00c21412e50Ecae098E7f9",
+    name: "Wrapped Ether",
+    symbol: "WETH",
+    decimals: 18,
+    logoUrl: "https://assets.coingecko.com/coins/images/2518/small/weth.png"
+  }
+];
+
+// src/tokens.ts
+var KnownTokens = {
+  ethereum: {
+    mainnet: EthereumTokens,
+    testnet: EthereumSepoliaTokens,
+    devnet: EthereumSepoliaTokens
+  },
+  base: {
+    mainnet: BaseTokens,
+    testnet: BaseSepoliaTokens,
+    devnet: BaseSepoliaTokens
+  },
+  arbitrum: {
+    mainnet: ArbitrumTokens
+  }
+};
+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
-import { ethers as ethers2 } from "ethers";
 var ERC20_ABI = [
   "function balanceOf(address owner) view returns (uint256)",
   "function decimals() view returns (uint8)",
@@ -205,235 +302,166 @@ var ERC20_ABI = [
   "function symbol() view returns (string)",
   "function totalSupply() view returns (uint256)"
 ];
-var KNOWN_TOKENS = {
-  ethereum: {
-    "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": {
-      name: "USD Coin",
-      symbol: "USDC",
-      decimals: 6,
-      logoUrl: "https://assets.coingecko.com/coins/images/6319/small/USD_Coin_icon.png"
-    },
-    "0xdAC17F958D2ee523a2206206994597C13D831ec7": {
-      name: "Tether USD",
-      symbol: "USDT",
-      decimals: 6,
-      logoUrl: "https://assets.coingecko.com/coins/images/325/small/Tether.png"
-    },
-    "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599": {
-      name: "Wrapped Bitcoin",
-      symbol: "WBTC",
-      decimals: 8,
-      logoUrl: "https://assets.coingecko.com/coins/images/7598/small/wrapped_bitcoin_wbtc.png"
-    },
-    "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2": {
-      name: "Wrapped Ether",
-      symbol: "WETH",
-      decimals: 18,
-      logoUrl: "https://assets.coingecko.com/coins/images/2518/small/weth.png"
-    },
-    "0x6B175474E89094C44Da98b954EedeAC495271d0F": {
-      name: "Dai Stablecoin",
-      symbol: "DAI",
-      decimals: 18,
-      logoUrl: "https://assets.coingecko.com/coins/images/9956/small/4943.png"
-    }
-  },
-  arbitrum: {
-    "0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8": {
-      name: "USD Coin",
-      symbol: "USDC",
-      decimals: 6,
-      logoUrl: "https://assets.coingecko.com/coins/images/6319/small/USD_Coin_icon.png"
-    },
-    "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9": {
-      name: "Tether USD",
-      symbol: "USDT",
-      decimals: 6,
-      logoUrl: "https://assets.coingecko.com/coins/images/325/small/Tether.png"
-    },
-    "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1": {
-      name: "Wrapped Ether",
-      symbol: "WETH",
-      decimals: 18,
-      logoUrl: "https://assets.coingecko.com/coins/images/2518/small/weth.png"
-    }
-  },
-  base: {
-    "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913": {
-      name: "USD Coin",
-      symbol: "USDC",
-      decimals: 6,
-      logoUrl: "https://assets.coingecko.com/coins/images/6319/small/USD_Coin_icon.png"
-    },
-    "0x4200000000000000000000000000000000000006": {
-      name: "Wrapped Ether",
-      symbol: "WETH",
-      decimals: 18,
-      logoUrl: "https://assets.coingecko.com/coins/images/2518/small/weth.png"
-    }
-  }
-};
 var WarpEvmDataLoader = class {
   constructor(config, chain) {
     this.config = config;
     this.chain = chain;
-    this.provider = new ethers2.JsonRpcProvider(getEvmApiUrl(this.config.env, this.chain.name));
-    this.chainConfig = getEvmChainConfig(this.chain.name, this.config.env);
+    const providerConfig = getProviderConfig(this.config, this.chain.name, this.config.env, this.chain.defaultApiUrl);
+    const network = new ethers.Network(this.chain.name, parseInt(this.chain.chainId));
+    this.provider = new ethers.JsonRpcProvider(providerConfig.url, network);
+    this.cache = new WarpCache2(config.cache?.type);
+    this.uniswapService = new UniswapService(this.cache, parseInt(this.chain.chainId));
   }
   async getAccount(address) {
-    try {
-      const balance = await this.provider.getBalance(address);
-      return {
-        address,
-        balance
-      };
-    } catch (error) {
-      throw new Error(`Failed to get account balance for ${address}: ${error}`);
-    }
+    const balance = await this.provider.getBalance(address);
+    return {
+      chain: this.chain.name,
+      address,
+      balance
+    };
   }
   async getAccountAssets(address) {
-    try {
-      const assets = [];
-      const tokenBalances = await this.getERC20TokenBalances(address);
-      for (const tokenBalance of tokenBalances) {
-        if (tokenBalance.balance > 0n) {
-          assets.push({
-            identifier: tokenBalance.tokenAddress,
-            name: tokenBalance.metadata.name,
-            amount: tokenBalance.balance,
-            decimals: tokenBalance.metadata.decimals,
-            logoUrl: tokenBalance.metadata.logoUrl || ""
-          });
-        }
+    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;
-    } catch (error) {
-      throw new Error(`Failed to get account assets for ${address}: ${error}`);
     }
+    return assets;
   }
-  async getERC20TokenBalances(address) {
-    const tokenBalances = [];
-    const knownTokens = KNOWN_TOKENS[this.chain.name] || {};
-    for (const [tokenAddress, metadata] of Object.entries(knownTokens)) {
-      try {
-        const balance = await this.getTokenBalance(address, tokenAddress);
-        if (balance > 0n) {
-          tokenBalances.push({
-            tokenAddress,
-            balance,
-            metadata
-          });
-        }
-      } catch (error) {
-        console.warn(`Failed to get balance for token ${tokenAddress}: ${error}`);
+  async getAsset(identifier) {
+    try {
+      if (identifier === this.chain.nativeToken.identifier) {
+        return this.chain.nativeToken;
       }
-    }
-    const additionalTokens = await this.detectTokensFromEvents(address);
-    for (const tokenAddress of additionalTokens) {
-      if (!knownTokens[tokenAddress]) {
-        try {
-          const metadata = await this.getTokenMetadata(tokenAddress);
-          const balance = await this.getTokenBalance(address, tokenAddress);
-          if (balance > 0n) {
-            tokenBalances.push({
-              tokenAddress,
-              balance,
-              metadata
-            });
-          }
-        } catch (error) {
-          console.warn(`Failed to get metadata/balance for detected token ${tokenAddress}: ${error}`);
-        }
+      const cacheKey = WarpCacheKey.Asset(this.config.env, this.chain.name, identifier);
+      const cachedAsset = this.cache.get(cacheKey);
+      if (cachedAsset) {
+        return cachedAsset;
       }
-    }
-    return tokenBalances;
-  }
-  async getTokenBalance(address, tokenAddress) {
-    try {
-      const contract = new ethers2.Contract(tokenAddress, ERC20_ABI, this.provider);
-      const balance = await contract.balanceOf(address);
-      return balance;
+      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) {
-      throw new Error(`Failed to get token balance: ${error}`);
+      return null;
     }
   }
-  async getTokenMetadata(tokenAddress) {
+  async getAction(identifier, awaitCompleted = false) {
     try {
-      const contract = new ethers2.Contract(tokenAddress, ERC20_ABI, this.provider);
-      const [name, symbol, decimals] = await Promise.all([contract.name(), contract.symbol(), contract.decimals()]);
+      const tx = await this.provider.getTransaction(identifier);
+      if (!tx) return null;
+      let receipt = await this.provider.getTransactionReceipt(identifier);
+      if (awaitCompleted && !receipt) {
+        receipt = await tx.wait();
+      }
+      const block = await this.provider.getBlock(tx.blockNumber || "latest");
       return {
-        name: name || "Unknown Token",
-        symbol: symbol || "UNKNOWN",
-        decimals: decimals || 18
+        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: receipt?.status === 1 ? "success" : receipt?.status === 0 ? "failed" : "pending",
+        createdAt: block?.timestamp ? new Date(Number(block.timestamp) * 1e3).toISOString() : (/* @__PURE__ */ new Date()).toISOString(),
+        error: receipt?.status === 0 ? "Transaction failed" : null,
+        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
+        }
       };
     } catch (error) {
-      throw new Error(`Failed to get token metadata: ${error}`);
+      return null;
     }
   }
-  async detectTokensFromEvents(address) {
-    try {
-      const currentBlock = await this.provider.getBlockNumber();
-      const fromBlock = Math.max(0, currentBlock - 1e4);
-      const filter = {
-        fromBlock,
-        toBlock: currentBlock,
-        topics: [
-          ethers2.id("Transfer(address,address,uint256)"),
-          null,
-          // from address (any)
-          ethers2.zeroPadValue(address, 32)
-          // to address (our target)
-        ]
-      };
-      const logs = await this.provider.getLogs(filter);
-      const tokenAddresses = /* @__PURE__ */ new Set();
-      for (const log of logs) {
-        tokenAddresses.add(log.address);
-      }
-      return Array.from(tokenAddresses);
-    } catch (error) {
-      console.warn(`Failed to detect tokens from events: ${error}`);
-      return [];
-    }
+  async getAccountActions(address, options) {
+    return [];
   }
-  // Additional utility methods for enhanced token support
-  async getTokenInfo(tokenAddress) {
-    try {
-      return await this.getTokenMetadata(tokenAddress);
-    } catch (error) {
-      console.warn(`Failed to get token info for ${tokenAddress}: ${error}`);
-      return null;
-    }
+  async 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: token.logoUrl || ""
+    }));
   }
-  async getTokenBalanceForAddress(address, tokenAddress) {
-    try {
-      return await this.getTokenBalance(address, tokenAddress);
-    } catch (error) {
-      throw new Error(`Failed to get token balance for ${tokenAddress}: ${error}`);
-    }
+  async getTokenBalance(address, tokenAddress) {
+    const contract = new ethers.Contract(tokenAddress, ERC20_ABI, this.provider);
+    const balance = await contract.balanceOf(address);
+    return balance;
   }
-  async getMultipleTokenBalances(address, tokenAddresses) {
-    const balances = /* @__PURE__ */ new Map();
-    await Promise.all(
-      tokenAddresses.map(async (tokenAddress) => {
-        try {
-          const balance = await this.getTokenBalance(address, tokenAddress);
-          balances.set(tokenAddress, balance);
-        } catch (error) {
-          console.warn(`Failed to get balance for token ${tokenAddress}: ${error}`);
-          balances.set(tokenAddress, 0n);
-        }
-      })
-    );
-    return balances;
+  async getTokenMetadata(tokenAddress) {
+    const uniswapMetadata = await this.uniswapService.getTokenMetadata(tokenAddress);
+    if (uniswapMetadata) {
+      return uniswapMetadata;
+    }
+    const contract = new ethers.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 {
-  applyResultsToMessages,
+  applyOutputToMessages,
   getNextInfo,
-  getWarpActionByIndex
+  getProviderConfig as getProviderConfig3,
+  getWarpActionByIndex,
+  getWarpWalletAddressFromConfig as getWarpWalletAddressFromConfig2
 } from "@vleap/warps";
 import { ethers as ethers4 } from "ethers";
 
@@ -444,6 +472,8 @@ var WarpEvmConstants = {
     ContractCall: 1e5,
     ContractDeploy: 5e5,
     Transfer: 21e3,
+    TokenTransfer: 65e3,
+    // ERC-20 transfer gas limit
     Approve: 46e3,
     Swap: 2e5
   },
@@ -510,19 +540,22 @@ var ExplorerUrls = {
   ["blockscout_base_sepolia" /* BlockscoutBaseSepolia */]: "https://sepolia.blockscout.com"
 };
 
-// src/WarpEvmResults.ts
+// src/WarpEvmOutput.ts
 import {
-  evaluateResultsCommon,
-  parseResultsOutIndex,
+  evaluateOutputCommon,
+  getProviderConfig as getProviderConfig2,
+  getWarpWalletAddressFromConfig,
+  parseOutputOutIndex,
   WarpConstants as WarpConstants2
 } from "@vleap/warps";
+import { ethers as ethers3 } from "ethers";
 
 // src/WarpEvmSerializer.ts
 import {
   WarpConstants,
   WarpSerializer
 } from "@vleap/warps";
-import { ethers as ethers3 } from "ethers";
+import { ethers as ethers2 } from "ethers";
 var SplitParamsRegex = new RegExp(`${WarpConstants.ArgParamsSeparator}(.*)`);
 var WarpEvmSerializer = class {
   constructor() {
@@ -530,10 +563,10 @@ var WarpEvmSerializer = class {
   }
   typedToString(value) {
     if (typeof value === "string") {
-      if (ethers3.isAddress(value)) {
+      if (ethers2.isAddress(value)) {
         return `address:${value}`;
       }
-      if (ethers3.isHexString(value) && !ethers3.isAddress(value)) {
+      if (ethers2.isHexString(value) && !ethers2.isAddress(value)) {
         return `hex:${value}`;
       }
       return `string:${value}`;
@@ -672,13 +705,61 @@ var WarpEvmSerializer = class {
   }
 };
 
-// src/WarpEvmResults.ts
-var WarpEvmResults = class {
-  constructor(config) {
+// 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 ethers3.Network(this.chain.name, parseInt(this.chain.chainId));
+    this.provider = new ethers3.JsonRpcProvider(providerConfig.url, network);
   }
-  async getTransactionExecutionResults(warp, tx) {
+  async getActionExecution(warp, actionIndex, tx) {
+    if (!tx) {
+      return this.createFailedExecution(warp, actionIndex);
+    }
+    if ("status" in tx && typeof tx.status === "string") {
+      return this.handleWarpChainAction(warp, actionIndex, tx);
+    }
+    return this.handleTransactionReceipt(warp, actionIndex, tx);
+  }
+  createFailedExecution(warp, actionIndex) {
+    return {
+      status: "error",
+      warp,
+      action: actionIndex,
+      user: getWarpWalletAddressFromConfig(this.config, this.chain.name),
+      txHash: "",
+      tx: null,
+      next: null,
+      values: { string: [], native: [] },
+      output: {},
+      messages: {}
+    };
+  }
+  handleWarpChainAction(warp, actionIndex, tx) {
+    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: getWarpWalletAddressFromConfig(this.config, this.chain.name),
+      txHash: transactionHash,
+      tx,
+      next: null,
+      values: { string: stringValues, native: rawValues },
+      output: {},
+      messages: {}
+    };
+  }
+  handleTransactionReceipt(warp, actionIndex, tx) {
     const success = tx.status === 1;
     const gasUsed = tx.gasUsed?.toString() || "0";
     const gasPrice = tx.gasPrice?.toString() || "0";
@@ -686,63 +767,92 @@ var WarpEvmResults = class {
     const transactionHash = tx.hash;
     const logs = tx.logs.map((log) => ({
       address: log.address,
-      topics: log.topics,
+      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 {
-      success,
+      status: success ? "success" : "error",
       warp,
-      action: 0,
-      user: this.config.user?.wallets?.evm || null,
+      action: actionIndex,
+      user: getWarpWalletAddressFromConfig(this.config, this.chain.name),
       txHash: transactionHash,
+      tx,
       next: null,
-      values: [transactionHash, blockNumber, gasUsed, gasPrice, ...logs.length > 0 ? logs : []],
-      results: {},
+      values: { string: stringValues, native: rawValues },
+      output: {},
       messages: {}
     };
   }
-  async extractQueryResults(warp, typedValues, actionIndex, inputs) {
-    const values = typedValues.map((t) => this.serializer.typedToString(t));
-    const valuesRaw = typedValues.map((t) => this.serializer.typedToNative(t)[1]);
-    let results = {};
-    if (!warp.results) return { values, results };
+  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 };
+    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 = valuesRaw[indices[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.results)) {
+    for (const [key, path] of Object.entries(warp.output)) {
       if (path.startsWith(WarpConstants2.Transform.Prefix)) continue;
-      const currentActionIndex = parseResultsOutIndex(path);
+      const currentActionIndex = parseOutputOutIndex(path);
       if (currentActionIndex !== null && currentActionIndex !== actionIndex) {
-        results[key] = null;
+        output[key] = null;
         continue;
       }
       if (path.startsWith("out.") || path === "out" || path.startsWith("out[")) {
-        results[key] = getNestedValue(path) || null;
+        output[key] = getNestedValue(path) || null;
       } else {
-        results[key] = path;
+        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;
     }
-    return { values, results: await evaluateResultsCommon(warp, results, actionIndex, inputs) };
   }
 };
 
 // src/WarpEvmExecutor.ts
 var WarpEvmExecutor = class {
-  constructor(config) {
+  constructor(config, chain) {
     this.config = config;
+    this.chain = chain;
     this.serializer = new WarpEvmSerializer();
-    this.provider = new ethers4.JsonRpcProvider(getEvmApiUrl(config.env));
-    this.results = new WarpEvmResults(config);
+    const providerConfig = getProviderConfig3(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(providerConfig.url, network);
+    this.output = new WarpEvmOutput(config, this.chain);
   }
   async createTransaction(executable) {
     const action = getWarpActionByIndex(executable.warp, executable.action);
@@ -760,13 +870,13 @@ var WarpEvmExecutor = class {
     return tx;
   }
   async createTransferTransaction(executable) {
-    const userWallet = this.config.user?.wallets?.[executable.chain.name];
+    const userWallet = getWarpWalletAddressFromConfig2(this.config, executable.chain.name);
     if (!userWallet) throw new Error("WarpEvmExecutor: createTransfer - user address not set");
     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,
@@ -776,21 +886,20 @@ var WarpEvmExecutor = class {
     return this.estimateGasAndSetDefaults(tx, userWallet);
   }
   async createContractCallTransaction(executable) {
-    const userWallet = this.config.user?.wallets?.[executable.chain.name];
+    const userWallet = getWarpWalletAddressFromConfig2(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 (!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}`);
-    }
+    if (!action || !("func" in action) || !action.func) throw new Error("WarpEvmExecutor: Contract action must have a function name");
+    if (!ethers4.isAddress(executable.destination)) throw new Error(`WarpEvmExecutor: Invalid contract address: ${executable.destination}`);
     try {
-      const iface = new ethers4.Interface([`function ${action.func}`]);
-      const encodedData = iface.encodeFunctionData(action.func, executable.args);
+      let iface;
+      try {
+        iface = new ethers4.Interface(JSON.parse(action.abi));
+      } catch {
+        iface = new ethers4.Interface([action.abi]);
+      }
+      const nativeArgs = executable.args.map((arg) => this.serializer.coreSerializer.stringToNative(arg)[1]);
+      const encodedData = iface.encodeFunctionData(action.func, nativeArgs);
       const tx = {
         to: executable.destination,
         value: executable.value,
@@ -801,101 +910,107 @@ var WarpEvmExecutor = class {
       throw new Error(`WarpEvmExecutor: Failed to encode function data for ${action.func}: ${error}`);
     }
   }
-  async executeQuery(executable) {
-    const action = getWarpActionByIndex(executable.warp, executable.action);
-    if (action.type !== "query") {
-      throw new Error(`WarpEvmExecutor: Invalid action type for executeQuery: ${action.type}`);
+  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 (!action.func) {
-      throw new Error("WarpEvmExecutor: Query action must have a function name");
+    if (nativeTokenTransfers.length === 0 && erc20Transfers.length === 1) {
+      return this.createSingleTokenTransfer(executable, erc20Transfers[0], userWallet);
     }
-    if (!ethers4.isAddress(executable.destination)) {
-      throw new Error(`WarpEvmExecutor: Invalid contract address for query: ${executable.destination}`);
+    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,
+      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 (!ethers4.isAddress(executable.destination)) throw new Error(`WarpEvmExecutor: Invalid address for query: ${executable.destination}`);
     try {
-      const iface = new ethers4.Interface([`function ${action.func}`]);
-      const encodedData = iface.encodeFunctionData(action.func, executable.args);
+      let iface;
+      try {
+        iface = new ethers4.Interface(JSON.parse(action.abi));
+      } catch {
+        iface = new ethers4.Interface([action.abi]);
+      }
+      const nativeArgs = executable.args.map((arg) => this.serializer.coreSerializer.stringToNative(arg)[1]);
+      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, results } = await this.results.extractQueryResults(
+      const { values, output } = await this.output.extractQueryOutput(
         executable.warp,
         decodedResult,
         executable.action,
         executable.resolvedInputs
       );
-      const next = getNextInfo(this.config, [], executable.warp, executable.action, results);
+      const next = getNextInfo(this.config, [], executable.warp, executable.action, output);
       return {
-        success: isSuccess,
+        status: isSuccess ? "success" : "error",
         warp: executable.warp,
         action: executable.action,
-        user: this.config.user?.wallets?.[executable.chain.name] || null,
+        user: getWarpWalletAddressFromConfig2(this.config, executable.chain.name),
         txHash: null,
+        tx: null,
         next,
         values,
-        results,
-        messages: applyResultsToMessages(executable.warp, results)
+        output: { ...output, _DATA: decodedResult },
+        messages: applyOutputToMessages(executable.warp, output, this.config)
       };
     } catch (error) {
       return {
-        success: false,
+        status: "error",
         warp: executable.warp,
         action: executable.action,
-        user: this.config.user?.wallets?.[executable.chain.name] || null,
+        user: getWarpWalletAddressFromConfig2(this.config, executable.chain.name),
         txHash: null,
+        tx: null,
         next: null,
-        values: [],
-        results: {},
+        values: { string: [], native: [] },
+        output: { _DATA: error },
         messages: {}
       };
     }
   }
-  async preprocessInput(chain, input, type, value) {
-    const typedValue = this.serializer.stringToTyped(value);
-    switch (type) {
-      case "address":
-        if (!ethers4.isAddress(typedValue)) {
-          throw new Error(`Invalid address format: ${typedValue}`);
-        }
-        return ethers4.getAddress(typedValue);
-      case "hex":
-        if (!ethers4.isHexString(typedValue)) {
-          throw new Error(`Invalid hex format: ${typedValue}`);
-        }
-        return typedValue;
-      case "uint8":
-      case "uint16":
-      case "uint32":
-      case "uint64":
-      case "biguint":
-        const bigIntValue = BigInt(typedValue);
-        if (bigIntValue < 0) {
-          throw new Error(`Negative value not allowed for type ${type}: ${typedValue}`);
-        }
-        return bigIntValue.toString();
-      default:
-        return String(typedValue);
-    }
-  }
   async estimateGasAndSetDefaults(tx, from) {
     try {
       const gasEstimate = await this.provider.estimateGas({
         ...tx,
         from
       });
-      if (gasEstimate < BigInt(WarpEvmConstants.Validation.MinGasLimit)) {
-        throw new Error(`Gas estimate too low: ${gasEstimate}`);
-      }
-      if (gasEstimate > BigInt(WarpEvmConstants.Validation.MaxGasLimit)) {
-        throw new Error(`Gas estimate too high: ${gasEstimate}`);
-      }
+      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
@@ -903,12 +1018,14 @@ var WarpEvmExecutor = class {
       } 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: ethers4.parseUnits(WarpEvmConstants.GasPrice.Default, "wei")
         };
@@ -916,19 +1033,29 @@ var WarpEvmExecutor = class {
     } 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: parseInt(this.chain.chainId),
         gasLimit: defaultGasLimit,
         gasPrice: ethers4.parseUnits(WarpEvmConstants.GasPrice.Default, "wei")
       };
     }
   }
-  async signMessage(message, privateKey) {
-    throw new Error("Not implemented");
+  async verifyMessage(message, signature) {
+    try {
+      const recoveredAddress = ethers4.verifyMessage(message, signature);
+      return recoveredAddress;
+    } catch (error) {
+      throw new Error(`Failed to verify message: ${error}`);
+    }
   }
 };
 
@@ -1016,155 +1143,379 @@ 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/WarpEvmWallet.ts
+import {
+  getProviderConfig as getProviderConfig4,
+  getWarpWalletMnemonicFromConfig,
+  getWarpWalletPrivateKeyFromConfig
+} from "@vleap/warps";
+import { ethers as ethers5 } from "ethers";
+var WarpEvmWallet = class {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    const providerConfig = getProviderConfig4(config, chain.name, config.env, chain.defaultApiUrl);
+    this.provider = new ethers5.JsonRpcProvider(providerConfig.url);
+  }
+  async signTransaction(tx) {
+    if (!tx || typeof tx !== "object") throw new Error("Invalid transaction object");
+    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 signTransactions(txs) {
+    if (txs.length === 0) return [];
+    if (txs.length > 1) {
+      const wallet = this.getWallet();
+      const address = wallet.address;
+      const currentNonce = await this.provider.getTransactionCount(address, "pending");
+      const signedTxs = [];
+      for (let i = 0; i < txs.length; i++) {
+        const tx = { ...txs[i] };
+        tx.nonce = currentNonce + i;
+        if (i > 0) {
+          const priorityReduction = BigInt(i * 1e9);
+          const minGasPrice = BigInt(1e9);
+          if (tx.maxFeePerGas && tx.maxPriorityFeePerGas) {
+            tx.maxFeePerGas = tx.maxFeePerGas > priorityReduction ? tx.maxFeePerGas - priorityReduction : minGasPrice;
+            tx.maxPriorityFeePerGas = tx.maxPriorityFeePerGas > priorityReduction ? tx.maxPriorityFeePerGas - priorityReduction : minGasPrice;
+            delete tx.gasPrice;
+          } else if (tx.gasPrice) {
+            tx.gasPrice = tx.gasPrice > priorityReduction ? tx.gasPrice - priorityReduction : minGasPrice;
+            delete tx.maxFeePerGas;
+            delete tx.maxPriorityFeePerGas;
+          }
+        }
+        const signedTx = await this.signTransaction(tx);
+        signedTxs.push(signedTx);
+      }
+      return signedTxs;
+    }
+    return Promise.all(txs.map(async (tx) => this.signTransaction(tx)));
+  }
+  async signMessage(message) {
+    const wallet = this.getWallet();
+    const signature = await wallet.signMessage(message);
+    return signature;
+  }
+  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");
+    const wallet = this.getWallet();
+    if (!wallet) throw new Error("Wallet not initialized - no private key provided");
+    const connectedWallet = wallet.connect(this.provider);
+    const txResponse = await connectedWallet.sendTransaction(tx);
+    return txResponse.hash;
+  }
+  async sendTransactions(txs) {
+    return Promise.all(txs.map(async (tx) => this.sendTransaction(tx)));
+  }
+  create(mnemonic) {
+    const wallet = ethers5.Wallet.fromPhrase(mnemonic);
+    return { address: wallet.address, privateKey: wallet.privateKey, mnemonic };
+  }
+  generate() {
+    const wallet = ethers5.Wallet.createRandom();
+    return { address: wallet.address, privateKey: wallet.privateKey, mnemonic: wallet.mnemonic?.phrase || "" };
+  }
+  getAddress() {
+    const wallet = this.getWallet();
+    return wallet.address;
+  }
+  getWallet() {
+    const privateKey = getWarpWalletPrivateKeyFromConfig(this.config, this.chain.name);
+    if (privateKey) return new ethers5.Wallet(privateKey);
+    const mnemonic = getWarpWalletMnemonicFromConfig(this.config, this.chain.name);
+    if (mnemonic) return ethers5.Wallet.fromPhrase(mnemonic);
+    throw new Error("No private key or mnemonic provided");
+  }
 };
 
 // src/chains/common.ts
-var createEvmAdapter = (chainName, chainPrefix, chainInfos) => {
+var createEvmAdapter = (chainName, chainInfos) => {
   return (config, fallback) => {
     if (!fallback) throw new Error(`${chainName} adapter requires a fallback adapter`);
     return {
-      chain: chainName,
       chainInfo: chainInfos[config.env],
-      prefix: chainPrefix,
-      builder: () => new WarpEvmBuilder(config),
-      executor: new WarpEvmExecutor(config),
-      results: new WarpEvmResults(config),
+      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])
+      dataLoader: new WarpEvmDataLoader(config, chainInfos[config.env]),
+      wallet: new WarpEvmWallet(config, chainInfos[config.env])
     };
   };
 };
 
 // src/chains/arbitrum.ts
-var ChainNameArbitrum = "arbitrum";
-var getArbitrumAdapter = createEvmAdapter(ChainNameArbitrum, "arb", {
-  devnet: {
-    name: ChainNameArbitrum,
-    displayName: "Arbitrum Devnet",
-    chainId: "421614",
+var NativeTokenArb = {
+  chain: WarpChainName6.Arbitrum,
+  identifier: "ARB",
+  symbol: "ARB",
+  name: "Arbitrum",
+  decimals: 18,
+  logoUrl: "https://vleap.ai/images/tokens/arb.svg"
+};
+var getArbitrumAdapter = createEvmAdapter(WarpChainName6.Arbitrum, {
+  mainnet: {
+    name: WarpChainName6.Arbitrum,
+    displayName: "Arbitrum",
+    chainId: "42161",
     blockTime: 1e3,
     addressHrp: "0x",
-    apiUrl: "https://sepolia-rollup.arbitrum.io/rpc",
-    nativeToken: "ETH"
+    defaultApiUrl: "https://arb1.arbitrum.io/rpc",
+    logoUrl: "https://vleap.ai/images/chains/arbitrum.svg",
+    nativeToken: NativeTokenArb
   },
   testnet: {
-    name: ChainNameArbitrum,
-    displayName: "Arbitrum Testnet",
-    chainId: "421613",
+    name: WarpChainName6.Arbitrum,
+    displayName: "Arbitrum Sepolia",
+    chainId: "421614",
     blockTime: 1e3,
     addressHrp: "0x",
-    apiUrl: "https://goerli-rollup.arbitrum.io/rpc",
-    nativeToken: "ETH"
+    defaultApiUrl: "https://sepolia-rollup.arbitrum.io/rpc",
+    logoUrl: "https://vleap.ai/images/chains/arbitrum.svg",
+    nativeToken: NativeTokenArb
   },
-  mainnet: {
-    name: ChainNameArbitrum,
-    displayName: "Arbitrum",
-    chainId: "42161",
+  devnet: {
+    name: WarpChainName6.Arbitrum,
+    displayName: "Arbitrum Sepolia",
+    chainId: "421614",
     blockTime: 1e3,
     addressHrp: "0x",
-    apiUrl: "https://arb1.arbitrum.io/rpc",
-    nativeToken: "ETH"
+    defaultApiUrl: "https://sepolia-rollup.arbitrum.io/rpc",
+    logoUrl: "https://vleap.ai/images/chains/arbitrum.svg",
+    nativeToken: NativeTokenArb
   }
 });
 
 // src/chains/base.ts
-var ChainNameBase = "base";
-var getBaseAdapter = createEvmAdapter(ChainNameBase, "base", {
+import { WarpChainName as WarpChainName7 } from "@vleap/warps";
+var NativeTokenBase = {
+  chain: WarpChainName7.Base,
+  identifier: "ETH",
+  name: "Ether",
+  symbol: "ETH",
+  decimals: 18,
+  logoUrl: "https://vleap.ai/images/tokens/eth.svg"
+};
+var getBaseAdapter = createEvmAdapter(WarpChainName7.Base, {
   mainnet: {
-    name: ChainNameBase,
+    name: WarpChainName7.Base,
     displayName: "Base",
     chainId: "8453",
     blockTime: 2e3,
     addressHrp: "0x",
-    apiUrl: "https://mainnet.base.org",
-    nativeToken: "ETH"
+    defaultApiUrl: "https://mainnet.base.org",
+    logoUrl: "https://vleap.ai/images/chains/base.svg",
+    nativeToken: NativeTokenBase
   },
   testnet: {
-    name: ChainNameBase,
-    displayName: "Base Testnet",
-    chainId: "84531",
+    name: WarpChainName7.Base,
+    displayName: "Base Sepolia",
+    chainId: "84532",
     blockTime: 2e3,
     addressHrp: "0x",
-    apiUrl: "https://goerli.base.org",
-    nativeToken: "ETH"
+    defaultApiUrl: "https://sepolia.base.org",
+    logoUrl: "https://vleap.ai/images/chains/base.svg",
+    nativeToken: NativeTokenBase
   },
   devnet: {
-    name: ChainNameBase,
-    displayName: "Base Devnet",
+    name: WarpChainName7.Base,
+    displayName: "Base Sepolia",
     chainId: "84532",
     blockTime: 2e3,
     addressHrp: "0x",
-    apiUrl: "https://sepolia.base.org",
-    nativeToken: "ETH"
+    defaultApiUrl: "https://sepolia.base.org",
+    logoUrl: "https://vleap.ai/images/chains/base.svg",
+    nativeToken: NativeTokenBase
   }
 });
 
+// src/chains/combined.ts
+import { WarpChainName as WarpChainName10 } from "@vleap/warps";
+
 // src/chains/ethereum.ts
-var ChainNameEthereum = "ethereum";
-var getEthereumAdapter = createEvmAdapter(ChainNameEthereum, "eth", {
-  devnet: {
-    name: ChainNameEthereum,
-    displayName: "Ethereum Devnet",
-    chainId: "11155111",
+import { WarpChainName as WarpChainName8 } from "@vleap/warps";
+var NativeTokenEth = {
+  chain: WarpChainName8.Ethereum,
+  identifier: "ETH",
+  symbol: "ETH",
+  name: "Ether",
+  decimals: 18,
+  logoUrl: "https://vleap.ai/images/tokens/eth.svg"
+};
+var getEthereumAdapter = createEvmAdapter(WarpChainName8.Ethereum, {
+  mainnet: {
+    name: WarpChainName8.Ethereum,
+    displayName: "Ethereum Mainnet",
+    chainId: "1",
     blockTime: 12e3,
     addressHrp: "0x",
-    apiUrl: "https://eth-sepolia.g.alchemy.com/v2/YOUR_API_KEY",
-    nativeToken: "ETH"
+    defaultApiUrl: "https://ethereum-rpc.publicnode.com",
+    logoUrl: "https://vleap.ai/images/chains/ethereum.svg",
+    nativeToken: NativeTokenEth
   },
   testnet: {
-    name: ChainNameEthereum,
-    displayName: "Ethereum Testnet",
-    chainId: "5",
+    name: WarpChainName8.Ethereum,
+    displayName: "Ethereum Sepolia",
+    chainId: "11155111",
     blockTime: 12e3,
     addressHrp: "0x",
-    apiUrl: "https://eth-goerli.g.alchemy.com/v2/YOUR_API_KEY",
-    nativeToken: "ETH"
+    defaultApiUrl: "https://ethereum-sepolia-rpc.publicnode.com",
+    logoUrl: "https://vleap.ai/images/chains/ethereum.svg",
+    nativeToken: NativeTokenEth
   },
-  mainnet: {
-    name: ChainNameEthereum,
-    displayName: "Ethereum Mainnet",
-    chainId: "1",
+  devnet: {
+    name: WarpChainName8.Ethereum,
+    displayName: "Ethereum Sepolia",
+    chainId: "11155111",
     blockTime: 12e3,
     addressHrp: "0x",
-    apiUrl: "https://eth-mainnet.g.alchemy.com/v2/YOUR_API_KEY",
-    nativeToken: "ETH"
+    defaultApiUrl: "https://ethereum-sepolia-rpc.publicnode.com",
+    logoUrl: "https://vleap.ai/images/chains/ethereum.svg",
+    nativeToken: NativeTokenEth
+  }
+});
+
+// src/chains/somnia.ts
+import { WarpChainName as WarpChainName9 } from "@vleap/warps";
+var NativeTokenSomi = {
+  chain: WarpChainName9.Somnia,
+  identifier: "SOMI",
+  symbol: "SOMI",
+  name: "Somnia",
+  decimals: 18,
+  logoUrl: "https://assets.coingecko.com/coins/images/68061/standard/somniacg.png?1754641117"
+};
+var NativeTokenStt = {
+  chain: WarpChainName9.Somnia,
+  identifier: "STT",
+  symbol: "STT",
+  name: "Somnia Testnet Token",
+  decimals: 18,
+  logoUrl: "https://assets.coingecko.com/coins/images/68061/standard/somniacg.png?1754641117"
+};
+var getSomniaAdapter = createEvmAdapter(WarpChainName9.Somnia, {
+  mainnet: {
+    name: WarpChainName9.Somnia,
+    displayName: "Somnia Mainnet",
+    chainId: "5031",
+    blockTime: 100,
+    addressHrp: "0x",
+    defaultApiUrl: "https://api.infra.mainnet.somnia.network/",
+    logoUrl: "https://vleap.ai/images/chains/somnia.png",
+    nativeToken: NativeTokenSomi
+  },
+  testnet: {
+    name: WarpChainName9.Somnia,
+    displayName: "Somnia Testnet",
+    chainId: "50312",
+    blockTime: 100,
+    addressHrp: "0x",
+    defaultApiUrl: "https://dream-rpc.somnia.network/",
+    logoUrl: "https://vleap.ai/images/chains/somnia.png",
+    nativeToken: NativeTokenStt
+  },
+  devnet: {
+    name: WarpChainName9.Somnia,
+    displayName: "Somnia Testnet",
+    chainId: "50312",
+    blockTime: 100,
+    addressHrp: "0x",
+    defaultApiUrl: "https://dream-rpc.somnia.network",
+    logoUrl: "https://vleap.ai/images/chains/somnia.png",
+    nativeToken: NativeTokenStt
   }
 });
 
 // src/chains/combined.ts
 var getAllEvmAdapters = (config, fallback) => [
   getEthereumAdapter(config, fallback),
+  getBaseAdapter(config, fallback),
   getArbitrumAdapter(config, fallback),
-  getBaseAdapter(config, fallback)
+  getSomniaAdapter(config, fallback)
+];
+var getAllEvmChainNames = () => [
+  WarpChainName10.Ethereum,
+  WarpChainName10.Base,
+  WarpChainName10.Arbitrum,
+  WarpChainName10.Somnia
 ];
-var getAllEvmChainNames = () => [ChainNameArbitrum, ChainNameBase, ChainNameEthereum];
 export {
   ArbitrumExplorers,
   BaseExplorers,
-  ChainNameArbitrum,
-  ChainNameBase,
-  ChainNameEthereum,
-  EVM_CHAIN_CONFIGS,
   EthereumExplorers,
   EvmExplorers,
   ExplorerUrls,
-  WarpEvmBuilder,
+  KnownTokens,
+  NativeTokenArb,
+  NativeTokenBase,
+  NativeTokenEth,
+  UniswapService,
   WarpEvmConstants,
+  WarpEvmDataLoader,
   WarpEvmExecutor,
   WarpEvmExplorer,
-  WarpEvmResults,
+  WarpEvmOutput,
   WarpEvmSerializer,
+  WarpEvmWallet,
+  createEvmAdapter,
+  findKnownTokenById,
   getAllEvmAdapters,
   getAllEvmChainNames,
   getArbitrumAdapter,
   getBaseAdapter,
   getEthereumAdapter,
-  getEvmApiUrl,
-  getEvmChainConfig,
-  getEvmExplorerUrl
+  getKnownTokensForChain
 };
 //# sourceMappingURL=index.mjs.map