@vleap/warps-adapter-evm 0.2.0-beta.59 → 0.2.0-beta.60

package/dist/index.mjs

@@ -99,11 +99,10 @@ var UniswapService = _UniswapService;
 // src/providers/PrivateKeyWalletProvider.ts
 import { ethers } from "ethers";
 import { getWarpWalletPrivateKeyFromConfig } from "@vleap/warps";
-var PrivateKeyWalletProvider = class {
-  constructor(config, chain, rpcProvider) {
+var _PrivateKeyWalletProvider = class _PrivateKeyWalletProvider {
+  constructor(config, chain) {
     this.config = config;
     this.chain = chain;
-    this.rpcProvider = rpcProvider;
     this.wallet = null;
   }
   async getAddress() {
@@ -146,21 +145,15 @@ var PrivateKeyWalletProvider = class {
     return this.getWallet();
   }
   create(mnemonic) {
-    const wallet = ethers.Wallet.fromPhrase(mnemonic);
-    return {
-      provider: "privateKey",
-      address: wallet.address,
-      privateKey: wallet.privateKey,
-      mnemonic
-    };
+    throw new Error("PrivateKeyWalletProvider does not support creating wallets from mnemonics. Use MnemonicWalletProvider instead.");
   }
   generate() {
     const wallet = ethers.Wallet.createRandom();
     return {
-      provider: "privateKey",
+      provider: _PrivateKeyWalletProvider.PROVIDER_NAME,
       address: wallet.address,
       privateKey: wallet.privateKey,
-      mnemonic: wallet.mnemonic?.phrase || null
+      mnemonic: null
     };
   }
   getWallet() {
@@ -171,15 +164,16 @@ var PrivateKeyWalletProvider = class {
     return this.wallet;
   }
 };
+_PrivateKeyWalletProvider.PROVIDER_NAME = "privateKey";
+var PrivateKeyWalletProvider = _PrivateKeyWalletProvider;
 
 // src/providers/MnemonicWalletProvider.ts
 import { ethers as ethers2 } from "ethers";
 import { getWarpWalletMnemonicFromConfig } from "@vleap/warps";
-var MnemonicWalletProvider = class {
-  constructor(config, chain, rpcProvider) {
+var _MnemonicWalletProvider = class _MnemonicWalletProvider {
+  constructor(config, chain) {
     this.config = config;
     this.chain = chain;
-    this.rpcProvider = rpcProvider;
     this.wallet = null;
   }
   async getAddress() {
@@ -224,18 +218,18 @@ var MnemonicWalletProvider = class {
   create(mnemonic) {
     const wallet = ethers2.Wallet.fromPhrase(mnemonic);
     return {
-      provider: "mnemonic",
+      provider: _MnemonicWalletProvider.PROVIDER_NAME,
       address: wallet.address,
-      privateKey: wallet.privateKey,
+      privateKey: null,
       mnemonic
     };
   }
   generate() {
     const wallet = ethers2.Wallet.createRandom();
     return {
-      provider: "mnemonic",
+      provider: _MnemonicWalletProvider.PROVIDER_NAME,
       address: wallet.address,
-      privateKey: wallet.privateKey,
+      privateKey: null,
       mnemonic: wallet.mnemonic?.phrase || null
     };
   }
@@ -247,6 +241,8 @@ var MnemonicWalletProvider = class {
     return this.wallet;
   }
 };
+_MnemonicWalletProvider.PROVIDER_NAME = "mnemonic";
+var MnemonicWalletProvider = _MnemonicWalletProvider;
 
 // src/providers/ReadOnlyWalletProvider.ts
 import { getWarpWalletAddressFromConfig } from "@vleap/warps";
@@ -1590,23 +1586,6 @@ var WarpEvmWallet = class {
     this.walletProvider = this.createProvider();
     this.initializeCache();
   }
-  createProvider() {
-    const wallet = this.config.user?.wallets?.[this.chain.name];
-    if (!wallet) return null;
-    if (typeof wallet === "string") return new ReadOnlyWalletProvider(this.config, this.chain);
-    const customWalletProviders = this.config.walletProviders?.[this.chain.name];
-    const providerFactory = customWalletProviders?.[wallet.provider];
-    if (providerFactory) return providerFactory(this.config, this.chain);
-    if (wallet.provider === "privateKey") return new PrivateKeyWalletProvider(this.config, this.chain, this.provider);
-    if (wallet.provider === "mnemonic") return new MnemonicWalletProvider(this.config, this.chain, this.provider);
-    throw new Error(`Unsupported wallet provider for ${this.chain.name}: ${wallet.provider}`);
-  }
-  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");
     if (!this.walletProvider) throw new Error("No wallet provider available");
@@ -1669,15 +1648,13 @@ var WarpEvmWallet = class {
   async sendTransactions(txs) {
     return Promise.all(txs.map(async (tx) => this.sendTransaction(tx)));
   }
-  create(mnemonic) {
-    if (!this.walletProvider) throw new Error("No wallet provider available");
-    if (this.walletProvider instanceof ReadOnlyWalletProvider) throw new Error(`Wallet (${this.chain.name}) is read-only`);
-    return this.walletProvider.create(mnemonic);
+  create(mnemonic, provider) {
+    const walletProvider = this.createProviderForOperation(provider);
+    return walletProvider.create(mnemonic);
   }
-  generate() {
-    if (!this.walletProvider) throw new Error("No wallet provider available");
-    if (this.walletProvider instanceof ReadOnlyWalletProvider) throw new Error(`Wallet (${this.chain.name}) is read-only`);
-    return this.walletProvider.generate();
+  generate(provider) {
+    const walletProvider = this.createProviderForOperation(provider);
+    return walletProvider.generate();
   }
   getAddress() {
     return this.cachedAddress;
@@ -1701,6 +1678,30 @@ var WarpEvmWallet = class {
     }
     return handlers;
   }
+  createProvider() {
+    const wallet = this.config.user?.wallets?.[this.chain.name];
+    if (!wallet) return null;
+    if (typeof wallet === "string") return new ReadOnlyWalletProvider(this.config, this.chain);
+    return this.createProviderForOperation(wallet.provider);
+  }
+  initializeCache() {
+    initializeWalletCache(this.walletProvider).then((cache) => {
+      this.cachedAddress = cache.address;
+      this.cachedPublicKey = cache.publicKey;
+    });
+  }
+  createProviderForOperation(provider) {
+    const customWalletProviders = this.config.walletProviders?.[this.chain.name];
+    const providerFactory = customWalletProviders?.[provider];
+    if (providerFactory) {
+      const walletProvider = providerFactory(this.config, this.chain);
+      if (!walletProvider) throw new Error(`Custom wallet provider factory returned null for ${provider}`);
+      return walletProvider;
+    }
+    if (provider === "privateKey") return new PrivateKeyWalletProvider(this.config, this.chain);
+    if (provider === "mnemonic") return new MnemonicWalletProvider(this.config, this.chain);
+    throw new Error(`Unsupported wallet provider for ${this.chain.name}: ${provider}`);
+  }
 };
 
 // src/chains/common.ts