@vleap/warps-adapter-solana 0.1.0-beta.5 → 0.1.0-beta.6

package/dist/index.mjs

@@ -1243,24 +1243,44 @@ var WarpSolanaExplorer = class {
 };
 
 // src/WarpSolanaWallet.ts
+import * as bip392 from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english.js";
+import { Connection as Connection5, Keypair as Keypair2, Transaction as Transaction3, VersionedTransaction as VersionedTransaction2 } from "@solana/web3.js";
 import {
   getProviderConfig as getProviderConfig4,
-  getWarpWalletMnemonicFromConfig,
-  getWarpWalletPrivateKeyFromConfig
+  initializeWalletCache
 } from "@vleap/warps";
-import { Connection as Connection4, Keypair, Transaction as Transaction2, VersionedTransaction } from "@solana/web3.js";
+import bs583 from "bs58";
+
+// src/providers/SolanaWalletProvider.ts
+import { Keypair, Transaction as Transaction2, VersionedTransaction } from "@solana/web3.js";
 import * as bip39 from "@scure/bip39";
-import { wordlist } from "@scure/bip39/wordlists/english.js";
 import bs582 from "bs58";
-var WarpSolanaWallet = class {
-  constructor(config, chain) {
+import { getWarpWalletMnemonicFromConfig, getWarpWalletPrivateKeyFromConfig } from "@vleap/warps";
+var SolanaWalletProvider = class {
+  constructor(config, chain, connection) {
     this.config = config;
     this.chain = chain;
-    const providerConfig = getProviderConfig4(config, chain.name, config.env, chain.defaultApiUrl);
-    this.connection = new Connection4(providerConfig.url, "confirmed");
+    this.connection = connection;
+    this.keypair = null;
+  }
+  async getAddress() {
+    try {
+      const keypair = this.getKeypair();
+      return keypair.publicKey.toBase58();
+    } catch {
+      return null;
+    }
+  }
+  async getPublicKey() {
+    try {
+      const keypair = this.getKeypair();
+      return keypair.publicKey.toBase58();
+    } catch {
+      return null;
+    }
   }
   async signTransaction(tx) {
-    if (!tx || typeof tx !== "object") throw new Error("Invalid transaction object");
     const keypair = this.getKeypair();
     if (tx instanceof VersionedTransaction) {
       tx.sign([keypair]);
@@ -1287,28 +1307,6 @@ var WarpSolanaWallet = class {
     }
     throw new Error("Invalid transaction format");
   }
-  async signTransactions(txs) {
-    if (txs.length === 0) return [];
-    const keypair = this.getKeypair();
-    return Promise.all(
-      txs.map(async (tx) => {
-        if (tx instanceof VersionedTransaction) {
-          tx.sign([keypair]);
-          return tx;
-        }
-        if (tx instanceof Transaction2) {
-          tx.sign(keypair);
-          return tx;
-        }
-        if (tx.transaction && typeof tx.transaction === "object") {
-          const transaction = Transaction2.from(tx.transaction);
-          transaction.sign(keypair);
-          return { ...tx, transaction: transaction.serialize() };
-        }
-        throw new Error("Invalid transaction format");
-      })
-    );
-  }
   async signMessage(message) {
     const keypair = this.getKeypair();
     const messageBytes = new TextEncoder().encode(message);
@@ -1325,26 +1323,90 @@ var WarpSolanaWallet = class {
     const signature = nacl.sign.detached(messageBytes, privateKeyBytes);
     return bs582.encode(signature);
   }
+  getKeypairInstance() {
+    return this.getKeypair();
+  }
+  getKeypair() {
+    if (this.keypair) return this.keypair;
+    const privateKey = getWarpWalletPrivateKeyFromConfig(this.config, this.chain.name);
+    if (privateKey) {
+      try {
+        const secretKey = bs582.decode(privateKey);
+        if (secretKey.length === 64) {
+          this.keypair = Keypair.fromSecretKey(secretKey);
+          return this.keypair;
+        } else if (secretKey.length === 32) {
+          this.keypair = Keypair.fromSeed(secretKey);
+          return this.keypair;
+        } else {
+          throw new Error(`Invalid private key length: expected 32 or 64 bytes, got ${secretKey.length}`);
+        }
+      } catch (error) {
+        if (error instanceof Error) {
+          throw new Error(`Invalid private key format: ${error.message}`);
+        }
+        throw new Error("Invalid private key format");
+      }
+    }
+    const mnemonic = getWarpWalletMnemonicFromConfig(this.config, this.chain.name);
+    if (mnemonic) {
+      const seed = bip39.mnemonicToSeedSync(mnemonic);
+      this.keypair = Keypair.fromSeed(seed.slice(0, 32));
+      return this.keypair;
+    }
+    throw new Error("No private key or mnemonic provided");
+  }
+};
+
+// src/WarpSolanaWallet.ts
+var WarpSolanaWallet = class {
+  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.connection = new Connection5(providerConfig.url, "confirmed");
+    this.walletProvider = walletProvider || new SolanaWalletProvider(config, chain, this.connection);
+    this.initializeCache();
+  }
+  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");
+    return await this.walletProvider.signTransaction(tx);
+  }
+  async signTransactions(txs) {
+    if (txs.length === 0) return [];
+    return Promise.all(txs.map(async (tx) => this.signTransaction(tx)));
+  }
+  async signMessage(message) {
+    return await this.walletProvider.signMessage(message);
+  }
   async sendTransaction(tx) {
     if (!tx || typeof tx !== "object") throw new Error("Invalid transaction object");
     let transaction;
-    if (tx instanceof VersionedTransaction) {
+    if (tx instanceof VersionedTransaction2) {
       transaction = tx;
-    } else if (tx instanceof Transaction2) {
+    } else if (tx instanceof Transaction3) {
       transaction = tx;
     } else if (tx.transaction) {
-      if (tx.transaction instanceof Transaction2) {
+      if (tx.transaction instanceof Transaction3) {
         transaction = tx.transaction;
-      } else if (tx.transaction instanceof VersionedTransaction) {
+      } else if (tx.transaction instanceof VersionedTransaction2) {
         transaction = tx.transaction;
       } else if (typeof tx.transaction === "object") {
         try {
-          transaction = Transaction2.from(tx.transaction);
+          transaction = Transaction3.from(tx.transaction);
         } catch {
           throw new Error("Invalid transaction format");
         }
       } else if (Buffer.isBuffer(tx.transaction) || typeof tx.transaction === "string") {
-        transaction = Transaction2.from(tx.transaction);
+        transaction = Transaction3.from(tx.transaction);
       } else {
         throw new Error("Transaction must be signed before sending");
       }
@@ -1361,65 +1423,29 @@ var WarpSolanaWallet = class {
     return Promise.all(txs.map(async (tx) => this.sendTransaction(tx)));
   }
   create(mnemonic) {
-    const seed = bip39.mnemonicToSeedSync(mnemonic);
-    const keypair = Keypair.fromSeed(seed.slice(0, 32));
+    const seed = bip392.mnemonicToSeedSync(mnemonic);
+    const keypair = Keypair2.fromSeed(seed.slice(0, 32));
     return {
       address: keypair.publicKey.toBase58(),
-      privateKey: bs582.encode(keypair.secretKey),
+      privateKey: bs583.encode(keypair.secretKey),
       mnemonic
     };
   }
   generate() {
-    const keypair = Keypair.generate();
+    const keypair = Keypair2.generate();
     const entropy = keypair.secretKey.slice(0, 16);
-    const mnemonic = bip39.entropyToMnemonic(entropy, wordlist);
+    const mnemonic = bip392.entropyToMnemonic(entropy, wordlist);
     return {
       address: keypair.publicKey.toBase58(),
-      privateKey: bs582.encode(keypair.secretKey),
+      privateKey: bs583.encode(keypair.secretKey),
       mnemonic
     };
   }
   getAddress() {
-    try {
-      const keypair = this.getKeypair();
-      return keypair.publicKey.toBase58();
-    } catch {
-      return null;
-    }
+    return this.cachedAddress;
   }
   getPublicKey() {
-    try {
-      const keypair = this.getKeypair();
-      return keypair.publicKey.toBase58();
-    } catch {
-      return null;
-    }
-  }
-  getKeypair() {
-    const privateKey = getWarpWalletPrivateKeyFromConfig(this.config, this.chain.name);
-    if (privateKey) {
-      try {
-        const secretKey = bs582.decode(privateKey);
-        if (secretKey.length === 64) {
-          return Keypair.fromSecretKey(secretKey);
-        } else if (secretKey.length === 32) {
-          return Keypair.fromSeed(secretKey);
-        } else {
-          throw new Error(`Invalid private key length: expected 32 or 64 bytes, got ${secretKey.length}`);
-        }
-      } catch (error) {
-        if (error instanceof Error) {
-          throw new Error(`Invalid private key format: ${error.message}`);
-        }
-        throw new Error("Invalid private key format");
-      }
-    }
-    const mnemonic = getWarpWalletMnemonicFromConfig(this.config, this.chain.name);
-    if (mnemonic) {
-      const seed = bip39.mnemonicToSeedSync(mnemonic);
-      return Keypair.fromSeed(seed.slice(0, 32));
-    }
-    throw new Error("No private key or mnemonic provided");
+    return this.cachedPublicKey;
   }
 };