@vleap/warps-adapter-evm 0.2.0-alpha.5 → 0.2.0-alpha.7

package/dist/index.mjs

@@ -196,13 +196,246 @@ var WarpEvmBuilder = class {
   }
 };
 
+// src/WarpEvmDataLoader.ts
+import { ethers as ethers2 } from "ethers";
+var ERC20_ABI = [
+  "function balanceOf(address owner) view returns (uint256)",
+  "function decimals() view returns (uint8)",
+  "function name() view returns (string)",
+  "function symbol() view returns (string)",
+  "function totalSupply() view returns (uint256)"
+];
+var KNOWN_TOKENS = {
+  ethereum: {
+    "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": {
+      name: "USD Coin",
+      symbol: "USDC",
+      decimals: 6,
+      logoUrl: "https://assets.coingecko.com/coins/images/6319/small/USD_Coin_icon.png"
+    },
+    "0xdAC17F958D2ee523a2206206994597C13D831ec7": {
+      name: "Tether USD",
+      symbol: "USDT",
+      decimals: 6,
+      logoUrl: "https://assets.coingecko.com/coins/images/325/small/Tether.png"
+    },
+    "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599": {
+      name: "Wrapped Bitcoin",
+      symbol: "WBTC",
+      decimals: 8,
+      logoUrl: "https://assets.coingecko.com/coins/images/7598/small/wrapped_bitcoin_wbtc.png"
+    },
+    "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2": {
+      name: "Wrapped Ether",
+      symbol: "WETH",
+      decimals: 18,
+      logoUrl: "https://assets.coingecko.com/coins/images/2518/small/weth.png"
+    },
+    "0x6B175474E89094C44Da98b954EedeAC495271d0F": {
+      name: "Dai Stablecoin",
+      symbol: "DAI",
+      decimals: 18,
+      logoUrl: "https://assets.coingecko.com/coins/images/9956/small/4943.png"
+    }
+  },
+  arbitrum: {
+    "0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8": {
+      name: "USD Coin",
+      symbol: "USDC",
+      decimals: 6,
+      logoUrl: "https://assets.coingecko.com/coins/images/6319/small/USD_Coin_icon.png"
+    },
+    "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9": {
+      name: "Tether USD",
+      symbol: "USDT",
+      decimals: 6,
+      logoUrl: "https://assets.coingecko.com/coins/images/325/small/Tether.png"
+    },
+    "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1": {
+      name: "Wrapped Ether",
+      symbol: "WETH",
+      decimals: 18,
+      logoUrl: "https://assets.coingecko.com/coins/images/2518/small/weth.png"
+    }
+  },
+  base: {
+    "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913": {
+      name: "USD Coin",
+      symbol: "USDC",
+      decimals: 6,
+      logoUrl: "https://assets.coingecko.com/coins/images/6319/small/USD_Coin_icon.png"
+    },
+    "0x4200000000000000000000000000000000000006": {
+      name: "Wrapped Ether",
+      symbol: "WETH",
+      decimals: 18,
+      logoUrl: "https://assets.coingecko.com/coins/images/2518/small/weth.png"
+    }
+  }
+};
+var WarpEvmDataLoader = class {
+  constructor(config, chain) {
+    this.config = config;
+    this.chain = chain;
+    this.provider = new ethers2.JsonRpcProvider(getEvmApiUrl(this.config.env, this.chain.name));
+    this.chainConfig = getEvmChainConfig(this.chain.name, this.config.env);
+  }
+  async getAccount(address) {
+    try {
+      const balance = await this.provider.getBalance(address);
+      return {
+        address,
+        balance
+      };
+    } catch (error) {
+      throw new Error(`Failed to get account balance for ${address}: ${error}`);
+    }
+  }
+  async getAccountAssets(address) {
+    try {
+      const assets = [];
+      const tokenBalances = await this.getERC20TokenBalances(address);
+      for (const tokenBalance of tokenBalances) {
+        if (tokenBalance.balance > 0n) {
+          assets.push({
+            identifier: tokenBalance.tokenAddress,
+            name: tokenBalance.metadata.name,
+            amount: tokenBalance.balance,
+            decimals: tokenBalance.metadata.decimals,
+            logoUrl: tokenBalance.metadata.logoUrl || ""
+          });
+        }
+      }
+      return assets;
+    } catch (error) {
+      throw new Error(`Failed to get account assets for ${address}: ${error}`);
+    }
+  }
+  async getERC20TokenBalances(address) {
+    const tokenBalances = [];
+    const knownTokens = KNOWN_TOKENS[this.chain.name] || {};
+    for (const [tokenAddress, metadata] of Object.entries(knownTokens)) {
+      try {
+        const balance = await this.getTokenBalance(address, tokenAddress);
+        if (balance > 0n) {
+          tokenBalances.push({
+            tokenAddress,
+            balance,
+            metadata
+          });
+        }
+      } catch (error) {
+        console.warn(`Failed to get balance for token ${tokenAddress}: ${error}`);
+      }
+    }
+    const additionalTokens = await this.detectTokensFromEvents(address);
+    for (const tokenAddress of additionalTokens) {
+      if (!knownTokens[tokenAddress]) {
+        try {
+          const metadata = await this.getTokenMetadata(tokenAddress);
+          const balance = await this.getTokenBalance(address, tokenAddress);
+          if (balance > 0n) {
+            tokenBalances.push({
+              tokenAddress,
+              balance,
+              metadata
+            });
+          }
+        } catch (error) {
+          console.warn(`Failed to get metadata/balance for detected token ${tokenAddress}: ${error}`);
+        }
+      }
+    }
+    return tokenBalances;
+  }
+  async getTokenBalance(address, tokenAddress) {
+    try {
+      const contract = new ethers2.Contract(tokenAddress, ERC20_ABI, this.provider);
+      const balance = await contract.balanceOf(address);
+      return balance;
+    } catch (error) {
+      throw new Error(`Failed to get token balance: ${error}`);
+    }
+  }
+  async getTokenMetadata(tokenAddress) {
+    try {
+      const contract = new ethers2.Contract(tokenAddress, ERC20_ABI, this.provider);
+      const [name, symbol, decimals] = await Promise.all([contract.name(), contract.symbol(), contract.decimals()]);
+      return {
+        name: name || "Unknown Token",
+        symbol: symbol || "UNKNOWN",
+        decimals: decimals || 18
+      };
+    } catch (error) {
+      throw new Error(`Failed to get token metadata: ${error}`);
+    }
+  }
+  async detectTokensFromEvents(address) {
+    try {
+      const currentBlock = await this.provider.getBlockNumber();
+      const fromBlock = Math.max(0, currentBlock - 1e4);
+      const filter = {
+        fromBlock,
+        toBlock: currentBlock,
+        topics: [
+          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 [];
+    }
+  }
+  // Additional utility methods for enhanced token support
+  async getTokenInfo(tokenAddress) {
+    try {
+      return await this.getTokenMetadata(tokenAddress);
+    } catch (error) {
+      console.warn(`Failed to get token info for ${tokenAddress}: ${error}`);
+      return null;
+    }
+  }
+  async getTokenBalanceForAddress(address, tokenAddress) {
+    try {
+      return await this.getTokenBalance(address, tokenAddress);
+    } catch (error) {
+      throw new Error(`Failed to get token balance for ${tokenAddress}: ${error}`);
+    }
+  }
+  async getMultipleTokenBalances(address, tokenAddresses) {
+    const balances = /* @__PURE__ */ new Map();
+    await Promise.all(
+      tokenAddresses.map(async (tokenAddress) => {
+        try {
+          const balance = await this.getTokenBalance(address, tokenAddress);
+          balances.set(tokenAddress, balance);
+        } catch (error) {
+          console.warn(`Failed to get balance for token ${tokenAddress}: ${error}`);
+          balances.set(tokenAddress, 0n);
+        }
+      })
+    );
+    return balances;
+  }
+};
+
 // src/WarpEvmExecutor.ts
 import {
   applyResultsToMessages,
   getNextInfo,
   getWarpActionByIndex
 } from "@vleap/warps";
-import { ethers as ethers3 } from "ethers";
+import { ethers as ethers4 } from "ethers";
 
 // src/constants.ts
 var WarpEvmConstants = {
@@ -289,7 +522,7 @@ import {
   WarpConstants,
   WarpSerializer
 } from "@vleap/warps";
-import { ethers as ethers2 } from "ethers";
+import { ethers as ethers3 } from "ethers";
 var SplitParamsRegex = new RegExp(`${WarpConstants.ArgParamsSeparator}(.*)`);
 var WarpEvmSerializer = class {
   constructor() {
@@ -297,10 +530,10 @@ var WarpEvmSerializer = class {
   }
   typedToString(value) {
     if (typeof value === "string") {
-      if (ethers2.isAddress(value)) {
+      if (ethers3.isAddress(value)) {
         return `address:${value}`;
       }
-      if (ethers2.isHexString(value) && !ethers2.isAddress(value)) {
+      if (ethers3.isHexString(value) && !ethers3.isAddress(value)) {
         return `hex:${value}`;
       }
       return `string:${value}`;
@@ -508,7 +741,7 @@ var WarpEvmExecutor = class {
   constructor(config) {
     this.config = config;
     this.serializer = new WarpEvmSerializer();
-    this.provider = new ethers3.JsonRpcProvider(getEvmApiUrl(config.env));
+    this.provider = new ethers4.JsonRpcProvider(getEvmApiUrl(config.env));
     this.results = new WarpEvmResults(config);
   }
   async createTransaction(executable) {
@@ -527,9 +760,9 @@ var WarpEvmExecutor = class {
     return tx;
   }
   async createTransferTransaction(executable) {
-    const userWallet = this.config.user?.wallets?.[executable.chain];
+    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) {
@@ -543,20 +776,20 @@ var WarpEvmExecutor = class {
     return this.estimateGasAndSetDefaults(tx, userWallet);
   }
   async createContractCallTransaction(executable) {
-    const userWallet = this.config.user?.wallets?.[executable.chain];
+    const userWallet = this.config.user?.wallets?.[executable.chain.name];
     if (!userWallet) throw new Error("WarpEvmExecutor: createContractCall - user address not set");
     const action = getWarpActionByIndex(executable.warp, executable.action);
     if (!action || !("func" in action) || !action.func) {
       throw new Error("WarpEvmExecutor: Contract action must have a function name");
     }
-    if (!ethers3.isAddress(executable.destination)) {
+    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,
@@ -576,11 +809,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,
@@ -599,7 +832,7 @@ var WarpEvmExecutor = class {
         success: isSuccess,
         warp: executable.warp,
         action: executable.action,
-        user: this.config.user?.wallets?.[executable.chain] || null,
+        user: this.config.user?.wallets?.[executable.chain.name] || null,
         txHash: null,
         next,
         values,
@@ -611,7 +844,7 @@ var WarpEvmExecutor = class {
         success: false,
         warp: executable.warp,
         action: executable.action,
-        user: this.config.user?.wallets?.[executable.chain] || null,
+        user: this.config.user?.wallets?.[executable.chain.name] || null,
         txHash: null,
         next: null,
         values: [],
@@ -624,12 +857,12 @@ var WarpEvmExecutor = class {
     const typedValue = this.serializer.stringToTyped(value);
     switch (type) {
       case "address":
-        if (!ethers3.isAddress(typedValue)) {
+        if (!ethers4.isAddress(typedValue)) {
           throw new Error(`Invalid address format: ${typedValue}`);
         }
-        return ethers3.getAddress(typedValue);
+        return ethers4.getAddress(typedValue);
       case "hex":
-        if (!ethers3.isHexString(typedValue)) {
+        if (!ethers4.isHexString(typedValue)) {
           throw new Error(`Invalid hex format: ${typedValue}`);
         }
         return typedValue;
@@ -677,7 +910,7 @@ var WarpEvmExecutor = class {
         return {
           ...tx,
           gasLimit: gasEstimate,
-          gasPrice: ethers3.parseUnits(WarpEvmConstants.GasPrice.Default, "wei")
+          gasPrice: ethers4.parseUnits(WarpEvmConstants.GasPrice.Default, "wei")
         };
       }
     } catch (error) {
@@ -690,7 +923,7 @@ var WarpEvmExecutor = class {
       return {
         ...tx,
         gasLimit: defaultGasLimit,
-        gasPrice: ethers3.parseUnits(WarpEvmConstants.GasPrice.Default, "wei")
+        gasPrice: ethers4.parseUnits(WarpEvmConstants.GasPrice.Default, "wei")
       };
     }
   }
@@ -706,7 +939,7 @@ var WarpEvmExplorer = class {
     this.config = config;
   }
   getExplorers() {
-    const chainExplorers = EvmExplorers[this.chain];
+    const chainExplorers = EvmExplorers[this.chain.name];
     if (!chainExplorers) {
       return ["Default"];
     }
@@ -721,7 +954,7 @@ var WarpEvmExplorer = class {
     return explorers[0];
   }
   getExplorerUrlByName(explorer) {
-    const userPreference = this.config.preferences?.explorers?.[this.chain];
+    const userPreference = this.config.preferences?.explorers?.[this.chain.name];
     if (userPreference && !explorer) {
       const url2 = ExplorerUrls[userPreference];
       if (url2) return url2;
@@ -800,14 +1033,17 @@ var createEvmAdapter = (chainName, chainPrefix, chainInfos) => {
       registry: fallback.registry,
       explorer: new WarpEvmExplorer(chainInfos[config.env], config),
       abiBuilder: () => fallback.abiBuilder(),
-      brandBuilder: () => fallback.brandBuilder()
+      brandBuilder: () => fallback.brandBuilder(),
+      dataLoader: new WarpEvmDataLoader(config, chainInfos[config.env])
     };
   };
 };
 
 // src/chains/arbitrum.ts
-var getArbitrumAdapter = createEvmAdapter("arbitrum", "arb", {
+var ChainNameArbitrum = "arbitrum";
+var getArbitrumAdapter = createEvmAdapter(ChainNameArbitrum, "arb", {
   devnet: {
+    name: ChainNameArbitrum,
     displayName: "Arbitrum Devnet",
     chainId: "421614",
     blockTime: 1e3,
@@ -816,6 +1052,7 @@ var getArbitrumAdapter = createEvmAdapter("arbitrum", "arb", {
     nativeToken: "ETH"
   },
   testnet: {
+    name: ChainNameArbitrum,
     displayName: "Arbitrum Testnet",
     chainId: "421613",
     blockTime: 1e3,
@@ -824,6 +1061,7 @@ var getArbitrumAdapter = createEvmAdapter("arbitrum", "arb", {
     nativeToken: "ETH"
   },
   mainnet: {
+    name: ChainNameArbitrum,
     displayName: "Arbitrum",
     chainId: "42161",
     blockTime: 1e3,
@@ -834,8 +1072,10 @@ var getArbitrumAdapter = createEvmAdapter("arbitrum", "arb", {
 });
 
 // src/chains/base.ts
-var getBaseAdapter = createEvmAdapter("base", "base", {
+var ChainNameBase = "base";
+var getBaseAdapter = createEvmAdapter(ChainNameBase, "base", {
   mainnet: {
+    name: ChainNameBase,
     displayName: "Base",
     chainId: "8453",
     blockTime: 2e3,
@@ -844,7 +1084,8 @@ var getBaseAdapter = createEvmAdapter("base", "base", {
     nativeToken: "ETH"
   },
   testnet: {
-    displayName: "Base",
+    name: ChainNameBase,
+    displayName: "Base Testnet",
     chainId: "84531",
     blockTime: 2e3,
     addressHrp: "0x",
@@ -852,7 +1093,8 @@ var getBaseAdapter = createEvmAdapter("base", "base", {
     nativeToken: "ETH"
   },
   devnet: {
-    displayName: "Base",
+    name: ChainNameBase,
+    displayName: "Base Devnet",
     chainId: "84532",
     blockTime: 2e3,
     addressHrp: "0x",
@@ -862,8 +1104,10 @@ var getBaseAdapter = createEvmAdapter("base", "base", {
 });
 
 // src/chains/ethereum.ts
-var getEthereumAdapter = createEvmAdapter("ethereum", "eth", {
+var ChainNameEthereum = "ethereum";
+var getEthereumAdapter = createEvmAdapter(ChainNameEthereum, "eth", {
   devnet: {
+    name: ChainNameEthereum,
     displayName: "Ethereum Devnet",
     chainId: "11155111",
     blockTime: 12e3,
@@ -872,6 +1116,7 @@ var getEthereumAdapter = createEvmAdapter("ethereum", "eth", {
     nativeToken: "ETH"
   },
   testnet: {
+    name: ChainNameEthereum,
     displayName: "Ethereum Testnet",
     chainId: "5",
     blockTime: 12e3,
@@ -880,6 +1125,7 @@ var getEthereumAdapter = createEvmAdapter("ethereum", "eth", {
     nativeToken: "ETH"
   },
   mainnet: {
+    name: ChainNameEthereum,
     displayName: "Ethereum Mainnet",
     chainId: "1",
     blockTime: 12e3,
@@ -895,9 +1141,13 @@ var getAllEvmAdapters = (config, fallback) => [
   getArbitrumAdapter(config, fallback),
   getBaseAdapter(config, fallback)
 ];
+var getAllEvmChainNames = () => [ChainNameArbitrum, ChainNameBase, ChainNameEthereum];
 export {
   ArbitrumExplorers,
   BaseExplorers,
+  ChainNameArbitrum,
+  ChainNameBase,
+  ChainNameEthereum,
   EVM_CHAIN_CONFIGS,
   EthereumExplorers,
   EvmExplorers,
@@ -909,6 +1159,7 @@ export {
   WarpEvmResults,
   WarpEvmSerializer,
   getAllEvmAdapters,
+  getAllEvmChainNames,
   getArbitrumAdapter,
   getBaseAdapter,
   getEthereumAdapter,