@vleap/warps-adapter-evm 0.2.0-beta.55 → 0.2.0-beta.56

package/dist/index.mjs

@@ -8,7 +8,7 @@ import {
   WarpCache as WarpCache2,
   WarpCacheKey
 } from "@vleap/warps";
-import { ethers } from "ethers";
+import { ethers as ethers3 } from "ethers";
 
 // src/providers/UniswapService.ts
 import { CacheTtl } from "@vleap/warps";
@@ -96,6 +96,126 @@ var _UniswapService = class _UniswapService {
 _UniswapService.UNISWAP_TOKEN_LIST_URL = "https://tokens.uniswap.org";
 var UniswapService = _UniswapService;
 
+// src/providers/PrivateKeyWalletProvider.ts
+import { ethers } from "ethers";
+import { getWarpWalletPrivateKeyFromConfig } from "@vleap/warps";
+var PrivateKeyWalletProvider = class {
+  constructor(config, chain, rpcProvider) {
+    this.config = config;
+    this.chain = chain;
+    this.rpcProvider = rpcProvider;
+    this.wallet = null;
+  }
+  async getAddress() {
+    try {
+      const wallet = this.getWallet();
+      return wallet.address;
+    } catch {
+      return null;
+    }
+  }
+  async getPublicKey() {
+    try {
+      const wallet = this.getWallet();
+      const publicKey = wallet.signingKey.publicKey;
+      return publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey;
+    } catch {
+      return null;
+    }
+  }
+  async signTransaction(tx) {
+    const wallet = this.getWallet();
+    const txRequest = {
+      to: tx.to,
+      data: tx.data,
+      value: tx.value || 0,
+      gasLimit: tx.gasLimit,
+      maxFeePerGas: tx.maxFeePerGas,
+      maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
+      nonce: tx.nonce,
+      chainId: tx.chainId
+    };
+    const signedTx = await wallet.signTransaction(txRequest);
+    return { ...tx, signature: signedTx };
+  }
+  async signMessage(message) {
+    const wallet = this.getWallet();
+    return await wallet.signMessage(message);
+  }
+  getWalletInstance() {
+    return this.getWallet();
+  }
+  getWallet() {
+    if (this.wallet) return this.wallet;
+    const privateKey = getWarpWalletPrivateKeyFromConfig(this.config, this.chain.name);
+    if (!privateKey) {
+      throw new Error("No private key provided");
+    }
+    this.wallet = new ethers.Wallet(privateKey);
+    return this.wallet;
+  }
+};
+
+// src/providers/MnemonicWalletProvider.ts
+import { ethers as ethers2 } from "ethers";
+import { getWarpWalletMnemonicFromConfig } from "@vleap/warps";
+var MnemonicWalletProvider = class {
+  constructor(config, chain, rpcProvider) {
+    this.config = config;
+    this.chain = chain;
+    this.rpcProvider = rpcProvider;
+    this.wallet = null;
+  }
+  async getAddress() {
+    try {
+      const wallet = this.getWallet();
+      return wallet.address;
+    } catch {
+      return null;
+    }
+  }
+  async getPublicKey() {
+    try {
+      const wallet = this.getWallet();
+      const publicKey = wallet.signingKey.publicKey;
+      return publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey;
+    } catch {
+      return null;
+    }
+  }
+  async signTransaction(tx) {
+    const wallet = this.getWallet();
+    const txRequest = {
+      to: tx.to,
+      data: tx.data,
+      value: tx.value || 0,
+      gasLimit: tx.gasLimit,
+      maxFeePerGas: tx.maxFeePerGas,
+      maxPriorityFeePerGas: tx.maxPriorityFeePerGas,
+      nonce: tx.nonce,
+      chainId: tx.chainId
+    };
+    const signedTx = await wallet.signTransaction(txRequest);
+    return { ...tx, signature: signedTx };
+  }
+  async signMessage(message) {
+    const wallet = this.getWallet();
+    return await wallet.signMessage(message);
+  }
+  getWalletInstance() {
+    return this.getWallet();
+  }
+  getWallet() {
+    if (this.wallet) return this.wallet;
+    const mnemonic = getWarpWalletMnemonicFromConfig(this.config, this.chain.name);
+    if (!mnemonic) {
+      throw new Error("No mnemonic provided");
+    }
+    this.wallet = ethers2.Wallet.fromPhrase(mnemonic);
+    return this.wallet;
+  }
+};
+
 // src/tokens/arbitrum.ts
 import { WarpChainName } from "@vleap/warps";
 var ArbitrumChain = WarpChainName.Arbitrum;
@@ -387,8 +507,8 @@ var WarpEvmDataLoader = class {
     this.config = config;
     this.chain = chain;
     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);
+    const network = new ethers3.Network(this.chain.name, parseInt(this.chain.chainId));
+    this.provider = new ethers3.JsonRpcProvider(providerConfig.url, network);
     this.cache = new WarpCache2(config.cache?.type);
     this.uniswapService = new UniswapService(this.cache, parseInt(this.chain.chainId));
   }
@@ -513,7 +633,7 @@ var WarpEvmDataLoader = class {
     }));
   }
   async getTokenBalance(address, tokenAddress) {
-    const contract = new ethers.Contract(tokenAddress, ERC20_ABI, this.provider);
+    const contract = new ethers3.Contract(tokenAddress, ERC20_ABI, this.provider);
     const balance = await contract.balanceOf(address);
     return balance;
   }
@@ -522,7 +642,7 @@ var WarpEvmDataLoader = class {
     if (uniswapMetadata) {
       return uniswapMetadata;
     }
-    const contract = new ethers.Contract(tokenAddress, ERC20_ABI, this.provider);
+    const contract = new ethers3.Contract(tokenAddress, ERC20_ABI, this.provider);
     const [name, symbol, decimals] = await Promise.all([
       contract.name().catch(() => "Unknown Token"),
       contract.symbol().catch(() => "UNKNOWN"),
@@ -546,7 +666,7 @@ import {
   getWarpActionByIndex,
   getWarpWalletAddressFromConfig as getWarpWalletAddressFromConfig2
 } from "@vleap/warps";
-import { ethers as ethers4 } from "ethers";
+import { ethers as ethers6 } from "ethers";
 
 // src/constants.ts
 var WarpEvmConstants = {
@@ -634,14 +754,14 @@ import {
   WarpCache as WarpCache3,
   WarpCacheKey as WarpCacheKey2
 } from "@vleap/warps";
-import { ethers as ethers3 } from "ethers";
+import { ethers as ethers5 } from "ethers";
 
 // src/WarpEvmSerializer.ts
 import {
   WarpConstants,
   WarpSerializer
 } from "@vleap/warps";
-import { ethers as ethers2 } from "ethers";
+import { ethers as ethers4 } from "ethers";
 var SplitParamsRegex = new RegExp(`${WarpConstants.ArgParamsSeparator}(.*)`);
 var WarpEvmSerializer = class {
   constructor() {
@@ -649,10 +769,10 @@ var WarpEvmSerializer = class {
   }
   typedToString(value) {
     if (typeof value === "string") {
-      if (ethers2.isAddress(value)) {
+      if (ethers4.isAddress(value)) {
         return `address:${value}`;
       }
-      if (ethers2.isHexString(value) && !ethers2.isAddress(value)) {
+      if (ethers4.isHexString(value) && !ethers4.isAddress(value)) {
         return `hex:${value}`;
       }
       return `string:${value}`;
@@ -799,8 +919,8 @@ var WarpEvmOutput = class {
     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);
+    const network = new ethers5.Network(this.chain.name, parseInt(this.chain.chainId));
+    this.provider = new ethers5.JsonRpcProvider(providerConfig.url, network);
     this.cache = new WarpCache3(config.cache?.type);
   }
   async getActionExecution(warp, actionIndex, tx) {
@@ -946,8 +1066,8 @@ var WarpEvmExecutor = class {
     this.chain = chain;
     this.serializer = new WarpEvmSerializer();
     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);
+    const network = new ethers6.Network(this.chain.name, parseInt(this.chain.chainId));
+    this.provider = new ethers6.JsonRpcProvider(providerConfig.url, network);
     this.output = new WarpEvmOutput(config, this.chain);
   }
   async createTransaction(executable) {
@@ -968,7 +1088,7 @@ var WarpEvmExecutor = class {
   async createTransferTransaction(executable) {
     const userWallet = getWarpWalletAddressFromConfig2(this.config, executable.chain.name);
     if (!userWallet) throw new Error("WarpEvmExecutor: createTransfer - user address not set");
-    if (!ethers4.isAddress(executable.destination)) {
+    if (!ethers6.isAddress(executable.destination)) {
       throw new Error(`WarpEvmExecutor: Invalid destination address: ${executable.destination}`);
     }
     if (executable.transfers && executable.transfers.length > 0) {
@@ -986,13 +1106,13 @@ var WarpEvmExecutor = class {
     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 (!ethers6.isAddress(executable.destination)) throw new Error(`WarpEvmExecutor: Invalid contract address: ${executable.destination}`);
     try {
       let iface;
       try {
-        iface = new ethers4.Interface(JSON.parse(action.abi));
+        iface = new ethers6.Interface(JSON.parse(action.abi));
       } catch {
-        iface = new ethers4.Interface([action.abi]);
+        iface = new ethers6.Interface([action.abi]);
       }
       const funcFragment = iface.getFunction(action.func);
       if (!funcFragment) throw new Error(`WarpEvmExecutor: Function ${action.func} not found in ABI`);
@@ -1034,10 +1154,10 @@ var WarpEvmExecutor = class {
     throw new Error("WarpEvmExecutor: Invalid transfer configuration");
   }
   async createSingleTokenTransfer(executable, transfer, userWallet) {
-    if (!ethers4.isAddress(transfer.identifier)) {
+    if (!ethers6.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 transferInterface = new ethers6.Interface(["function transfer(address to, uint256 amount) returns (bool)"]);
     const encodedData = transferInterface.encodeFunctionData("transfer", [executable.destination, transfer.amount]);
     const tx = {
       to: transfer.identifier,
@@ -1050,13 +1170,13 @@ var WarpEvmExecutor = class {
     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}`);
+    if (!ethers6.isAddress(executable.destination)) throw new Error(`WarpEvmExecutor: Invalid address for query: ${executable.destination}`);
     try {
       let iface;
       try {
-        iface = new ethers4.Interface(JSON.parse(action.abi));
+        iface = new ethers6.Interface(JSON.parse(action.abi));
       } catch {
-        iface = new ethers4.Interface([action.abi]);
+        iface = new ethers6.Interface([action.abi]);
       }
       const funcFragment = iface.getFunction(action.func);
       if (!funcFragment) throw new Error(`WarpEvmExecutor: Function ${action.func} not found in ABI`);
@@ -1141,7 +1261,7 @@ var WarpEvmExecutor = class {
           ...tx,
           chainId: parseInt(this.chain.chainId),
           gasLimit: gasEstimate,
-          gasPrice: ethers4.parseUnits(WarpEvmConstants.GasPrice.Default, "wei")
+          gasPrice: ethers6.parseUnits(WarpEvmConstants.GasPrice.Default, "wei")
         };
       }
     } catch (error) {
@@ -1159,13 +1279,13 @@ var WarpEvmExecutor = class {
         ...tx,
         chainId: parseInt(this.chain.chainId),
         gasLimit: defaultGasLimit,
-        gasPrice: ethers4.parseUnits(WarpEvmConstants.GasPrice.Default, "wei")
+        gasPrice: ethers6.parseUnits(WarpEvmConstants.GasPrice.Default, "wei")
       };
     }
   }
   async verifyMessage(message, signature) {
     try {
-      const recoveredAddress = ethers4.verifyMessage(message, signature);
+      const recoveredAddress = ethers6.verifyMessage(message, signature);
       return recoveredAddress;
     } catch (error) {
       throw new Error(`Failed to verify message: ${error}`);
@@ -1211,7 +1331,7 @@ var WarpEvmExecutor = class {
           hexValue = "0x" + hexValue;
         }
         if (hexValue.length !== 66) {
-          hexValue = ethers4.zeroPadValue(hexValue, 32);
+          hexValue = ethers6.zeroPadValue(hexValue, 32);
         }
         return hexValue;
       }
@@ -1342,107 +1462,108 @@ var WarpEvmExplorer = class {
 // src/WarpEvmWallet.ts
 import {
   getProviderConfig as getProviderConfig4,
-  getWarpWalletMnemonicFromConfig,
-  getWarpWalletPrivateKeyFromConfig
+  getWarpWalletMnemonicFromConfig as getWarpWalletMnemonicFromConfig2,
+  getWarpWalletPrivateKeyFromConfig as getWarpWalletPrivateKeyFromConfig2,
+  initializeWalletCache
 } from "@vleap/warps";
-import { ethers as ethers5 } from "ethers";
+import { ethers as ethers7 } from "ethers";
 var WarpEvmWallet = class {
-  constructor(config, chain) {
+  constructor(config, chain, walletProvider) {
     this.config = config;
     this.chain = chain;
+    this.cachedAddress = null;
+    this.cachedPublicKey = null;
     const providerConfig = getProviderConfig4(config, chain.name, config.env, chain.defaultApiUrl);
-    this.provider = new ethers5.JsonRpcProvider(providerConfig.url);
+    this.provider = new ethers7.JsonRpcProvider(providerConfig.url);
+    this.walletProvider = walletProvider || this.createDefaultProvider();
+    this.initializeCache();
+  }
+  createDefaultProvider() {
+    const privateKey = getWarpWalletPrivateKeyFromConfig2(this.config, this.chain.name);
+    if (privateKey) {
+      return new PrivateKeyWalletProvider(this.config, this.chain, this.provider);
+    }
+    const mnemonic = getWarpWalletMnemonicFromConfig2(this.config, this.chain.name);
+    if (mnemonic) {
+      return new MnemonicWalletProvider(this.config, this.chain, this.provider);
+    }
+    return null;
+  }
+  initializeCache() {
+    initializeWalletCache(this.walletProvider).then((cache) => {
+      this.cachedAddress = cache.address;
+      this.cachedPublicKey = cache.publicKey;
+    });
   }
   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 };
+    if (!this.walletProvider) throw new Error("No wallet provider available");
+    return await this.walletProvider.signTransaction(tx);
   }
   async signTransactions(txs) {
     if (txs.length === 0) return [];
-    if (txs.length > 1) {
-      const wallet = this.getWallet();
+    if (!this.walletProvider) throw new Error("No wallet provider available");
+    if (this.walletProvider instanceof PrivateKeyWalletProvider || this.walletProvider instanceof MnemonicWalletProvider) {
+      const wallet = this.walletProvider.getWalletInstance();
       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;
+      if (txs.length > 1) {
+        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;
+            }
           }
+          signedTxs.push(await this.signTransaction(tx));
         }
-        const signedTx = await this.signTransaction(tx);
-        signedTxs.push(signedTx);
+        return signedTxs;
       }
-      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;
+    if (!this.walletProvider) throw new Error("No wallet provider available");
+    return await this.walletProvider.signMessage(message);
   }
   async sendTransaction(tx) {
     if (!tx || typeof tx !== "object") throw new Error("Invalid transaction object");
     if (!tx.signature) throw new Error("Transaction must be signed before sending");
-    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;
+    if (!this.walletProvider) throw new Error("No wallet provider available");
+    if (this.walletProvider instanceof PrivateKeyWalletProvider || this.walletProvider instanceof MnemonicWalletProvider) {
+      const wallet = this.walletProvider.getWalletInstance();
+      const connectedWallet = wallet.connect(this.provider);
+      const txResponse = await connectedWallet.sendTransaction(tx);
+      return txResponse.hash;
+    }
+    throw new Error("Wallet provider does not support sending transactions");
   }
   async sendTransactions(txs) {
     return Promise.all(txs.map(async (tx) => this.sendTransaction(tx)));
   }
   create(mnemonic) {
-    const wallet = ethers5.Wallet.fromPhrase(mnemonic);
+    const wallet = ethers7.Wallet.fromPhrase(mnemonic);
     return { address: wallet.address, privateKey: wallet.privateKey, mnemonic };
   }
   generate() {
-    const wallet = ethers5.Wallet.createRandom();
+    const wallet = ethers7.Wallet.createRandom();
     return { address: wallet.address, privateKey: wallet.privateKey, mnemonic: wallet.mnemonic?.phrase || "" };
   }
   getAddress() {
-    const wallet = this.getWallet();
-    return wallet.address;
+    return this.cachedAddress;
   }
   getPublicKey() {
-    try {
-      const wallet = this.getWallet();
-      const publicKey = wallet.signingKey.publicKey;
-      return publicKey.startsWith("0x") ? publicKey.slice(2) : publicKey;
-    } catch {
-      return null;
-    }
-  }
-  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");
+    return this.cachedPublicKey;
   }
 };
 
@@ -1668,9 +1789,11 @@ export {
   EvmExplorers,
   ExplorerUrls,
   KnownTokens,
+  MnemonicWalletProvider,
   NativeTokenArb,
   NativeTokenBase,
   NativeTokenEth,
+  PrivateKeyWalletProvider,
   UniswapService,
   WarpEvmConstants,
   WarpEvmDataLoader,