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

package/dist/index.mjs

@@ -65,6 +65,11 @@ var SolanaExplorerNames = {
   devnet: ["solscan_devnet" /* SolscanDevnet */, "solana_explorer_devnet" /* SolanaExplorerDevnet */]
 };
 var SolanaExplorerUrls = ExplorerUrls;
+var X402SolanaNetworkIdentifiers = {
+  Mainnet: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+  Devnet: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1"
+};
+var SupportedX402SolanaNetworks = [X402SolanaNetworkIdentifiers.Mainnet, X402SolanaNetworkIdentifiers.Devnet];
 
 // src/tokens/solana.ts
 import { WarpChainName } from "@vleap/warps";
@@ -1243,24 +1248,49 @@ var WarpSolanaExplorer = class {
 };
 
 // src/WarpSolanaWallet.ts
+import { createKeyPairSignerFromBytes } from "@solana/kit";
+import { Connection as Connection6, Transaction as Transaction4, VersionedTransaction as VersionedTransaction3 } 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 { registerExactSvmScheme } from "@x402/svm/exact/client";
+
+// src/providers/MnemonicWalletProvider.ts
 import * as bip39 from "@scure/bip39";
 import { wordlist } from "@scure/bip39/wordlists/english.js";
+import { Keypair, Transaction as Transaction2, VersionedTransaction } from "@solana/web3.js";
+import {
+  getWarpWalletAddressFromConfig as getWarpWalletAddressFromConfig3,
+  getWarpWalletMnemonicFromConfig
+} from "@vleap/warps";
 import bs582 from "bs58";
-var WarpSolanaWallet = class {
-  constructor(config, chain) {
+var MnemonicWalletProvider = 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() {
+    const address = getWarpWalletAddressFromConfig3(this.config, this.chain.name);
+    if (address) return address;
+    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 +1317,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,45 +1333,14 @@ var WarpSolanaWallet = class {
     const signature = nacl.sign.detached(messageBytes, privateKeyBytes);
     return bs582.encode(signature);
   }
-  async sendTransaction(tx) {
-    if (!tx || typeof tx !== "object") throw new Error("Invalid transaction object");
-    let transaction;
-    if (tx instanceof VersionedTransaction) {
-      transaction = tx;
-    } else if (tx instanceof Transaction2) {
-      transaction = tx;
-    } else if (tx.transaction) {
-      if (tx.transaction instanceof Transaction2) {
-        transaction = tx.transaction;
-      } else if (tx.transaction instanceof VersionedTransaction) {
-        transaction = tx.transaction;
-      } else if (typeof tx.transaction === "object") {
-        try {
-          transaction = Transaction2.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);
-      } else {
-        throw new Error("Transaction must be signed before sending");
-      }
-    } else {
-      throw new Error("Transaction must be signed before sending");
-    }
-    const signature = await this.connection.sendRawTransaction(transaction.serialize(), {
-      skipPreflight: true,
-      maxRetries: 3
-    });
-    return signature;
-  }
-  async sendTransactions(txs) {
-    return Promise.all(txs.map(async (tx) => this.sendTransaction(tx)));
+  getKeypairInstance() {
+    return this.getKeypair();
   }
   create(mnemonic) {
     const seed = bip39.mnemonicToSeedSync(mnemonic);
     const keypair = Keypair.fromSeed(seed.slice(0, 32));
     return {
+      provider: "mnemonic",
       address: keypair.publicKey.toBase58(),
       privateKey: bs582.encode(keypair.secretKey),
       mnemonic
@@ -1374,12 +1351,41 @@ var WarpSolanaWallet = class {
     const entropy = keypair.secretKey.slice(0, 16);
     const mnemonic = bip39.entropyToMnemonic(entropy, wordlist);
     return {
+      provider: "mnemonic",
       address: keypair.publicKey.toBase58(),
       privateKey: bs582.encode(keypair.secretKey),
       mnemonic
     };
   }
-  getAddress() {
+  getKeypair() {
+    if (this.keypair) return this.keypair;
+    const mnemonic = getWarpWalletMnemonicFromConfig(this.config, this.chain.name);
+    if (!mnemonic) throw new Error("No mnemonic provided");
+    const seed = bip39.mnemonicToSeedSync(mnemonic);
+    this.keypair = Keypair.fromSeed(seed.slice(0, 32));
+    return this.keypair;
+  }
+};
+
+// src/providers/PrivateKeyWalletProvider.ts
+import * as bip392 from "@scure/bip39";
+import { wordlist as wordlist2 } from "@scure/bip39/wordlists/english.js";
+import { Keypair as Keypair2, Transaction as Transaction3, VersionedTransaction as VersionedTransaction2 } from "@solana/web3.js";
+import {
+  getWarpWalletAddressFromConfig as getWarpWalletAddressFromConfig4,
+  getWarpWalletPrivateKeyFromConfig
+} from "@vleap/warps";
+import bs583 from "bs58";
+var PrivateKeyWalletProvider = class {
+  constructor(config, chain, connection) {
+    this.config = config;
+    this.chain = chain;
+    this.connection = connection;
+    this.keypair = null;
+  }
+  async getAddress() {
+    const address = getWarpWalletAddressFromConfig4(this.config, this.chain.name);
+    if (address) return address;
     try {
       const keypair = this.getKeypair();
       return keypair.publicKey.toBase58();
@@ -1387,7 +1393,7 @@ var WarpSolanaWallet = class {
       return null;
     }
   }
-  getPublicKey() {
+  async getPublicKey() {
     try {
       const keypair = this.getKeypair();
       return keypair.publicKey.toBase58();
@@ -1395,31 +1401,203 @@ var WarpSolanaWallet = class {
       return null;
     }
   }
+  async signTransaction(tx) {
+    const keypair = this.getKeypair();
+    if (tx instanceof VersionedTransaction2) {
+      tx.sign([keypair]);
+      return tx;
+    }
+    if (tx instanceof Transaction3) {
+      tx.sign(keypair);
+      return tx;
+    }
+    if (tx.transaction) {
+      if (tx.transaction instanceof Transaction3) {
+        tx.transaction.sign(keypair);
+        return { ...tx, transaction: tx.transaction.serialize() };
+      }
+      if (typeof tx.transaction === "object") {
+        try {
+          const transaction = Transaction3.from(tx.transaction);
+          transaction.sign(keypair);
+          return { ...tx, transaction: transaction.serialize(), signature: transaction.signature };
+        } catch {
+          throw new Error("Invalid transaction format");
+        }
+      }
+    }
+    throw new Error("Invalid transaction format");
+  }
+  async signMessage(message) {
+    const keypair = this.getKeypair();
+    const messageBytes = new TextEncoder().encode(message);
+    const nacl = await import("tweetnacl");
+    const secretKey = keypair.secretKey;
+    if (secretKey.length !== 64) {
+      throw new Error(`Invalid secret key length: expected 64, got ${secretKey.length}`);
+    }
+    const privateKeySlice = secretKey.slice(0, 32);
+    const privateKeyBytes = new Uint8Array(privateKeySlice);
+    if (privateKeyBytes.length !== 32) {
+      throw new Error(`Invalid private key length: expected 32, got ${privateKeyBytes.length}`);
+    }
+    const signature = nacl.sign.detached(messageBytes, privateKeyBytes);
+    return bs583.encode(signature);
+  }
+  getKeypairInstance() {
+    return this.getKeypair();
+  }
+  create(mnemonic) {
+    const seed = bip392.mnemonicToSeedSync(mnemonic);
+    const keypair = Keypair2.fromSeed(seed.slice(0, 32));
+    return {
+      provider: "privateKey",
+      address: keypair.publicKey.toBase58(),
+      privateKey: bs583.encode(keypair.secretKey),
+      mnemonic
+    };
+  }
+  generate() {
+    const keypair = Keypair2.generate();
+    const entropy = keypair.secretKey.slice(0, 16);
+    const mnemonic = bip392.entropyToMnemonic(entropy, wordlist2);
+    return {
+      provider: "privateKey",
+      address: keypair.publicKey.toBase58(),
+      privateKey: bs583.encode(keypair.secretKey),
+      mnemonic
+    };
+  }
   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) {
-          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}`);
+    if (!privateKey) throw new Error("No private key provided");
+    try {
+      const secretKey = bs583.decode(privateKey);
+      if (secretKey.length === 64) {
+        this.keypair = Keypair2.fromSecretKey(secretKey);
+        return this.keypair;
+      } else if (secretKey.length === 32) {
+        this.keypair = Keypair2.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");
+    }
+  }
+};
+
+// src/WarpSolanaWallet.ts
+var WarpSolanaWallet = class {
+  constructor(config, chain) {
+    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 Connection6(providerConfig.url, "confirmed");
+    this.walletProvider = this.createProvider();
+    this.initializeCache();
+  }
+  createProvider() {
+    const wallet = this.config.user?.wallets?.[this.chain.name];
+    if (!wallet) return null;
+    if (typeof wallet === "string") throw new Error(`Wallet can not be used for signing: ${wallet}`);
+    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.connection);
+    if (wallet.provider === "mnemonic") return new MnemonicWalletProvider(this.config, this.chain, this.connection);
+    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");
+    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) {
+    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");
+    let transaction;
+    if (tx instanceof VersionedTransaction3) {
+      transaction = tx;
+    } else if (tx instanceof Transaction4) {
+      transaction = tx;
+    } else if (tx.transaction) {
+      if (tx.transaction instanceof Transaction4) {
+        transaction = tx.transaction;
+      } else if (tx.transaction instanceof VersionedTransaction3) {
+        transaction = tx.transaction;
+      } else if (typeof tx.transaction === "object") {
+        try {
+          transaction = Transaction4.from(tx.transaction);
+        } catch {
+          throw new Error("Invalid transaction format");
         }
-        throw new Error("Invalid private key format");
+      } else if (Buffer.isBuffer(tx.transaction) || typeof tx.transaction === "string") {
+        transaction = Transaction4.from(tx.transaction);
+      } else {
+        throw new Error("Transaction must be signed before sending");
       }
+    } else {
+      throw new Error("Transaction must be signed before sending");
     }
-    const mnemonic = getWarpWalletMnemonicFromConfig(this.config, this.chain.name);
-    if (mnemonic) {
-      const seed = bip39.mnemonicToSeedSync(mnemonic);
-      return Keypair.fromSeed(seed.slice(0, 32));
+    const signature = await this.connection.sendRawTransaction(transaction.serialize(), {
+      skipPreflight: true,
+      maxRetries: 3
+    });
+    return signature;
+  }
+  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");
+    return this.walletProvider.create(mnemonic);
+  }
+  generate() {
+    if (!this.walletProvider) throw new Error("No wallet provider available");
+    return this.walletProvider.generate();
+  }
+  getAddress() {
+    return this.cachedAddress;
+  }
+  getPublicKey() {
+    return this.cachedPublicKey;
+  }
+  async registerX402Handlers(client) {
+    if (!this.walletProvider) return {};
+    const provider = this.walletProvider;
+    const getKeypair = provider.getKeypairInstance;
+    if (typeof getKeypair !== "function") return {};
+    const keypair = getKeypair();
+    if (!keypair || !keypair.secretKey) return {};
+    const signer = await createKeyPairSignerFromBytes(keypair.secretKey);
+    const handlers = {};
+    for (const network of SupportedX402SolanaNetworks) {
+      handlers[network] = () => {
+        registerExactSvmScheme(client, { signer });
+      };
     }
-    throw new Error("No private key or mnemonic provided");
+    return handlers;
   }
 };
 
@@ -1452,7 +1630,7 @@ var NativeTokenSol = {
   decimals: 9,
   logoUrl: "https://joai.ai/images/tokens/sol.svg"
 };
-var getSolanaAdapter = createSolanaAdapter(WarpChainName2.Solana, {
+var SolanaAdapter = createSolanaAdapter(WarpChainName2.Solana, {
   mainnet: {
     name: WarpChainName2.Solana,
     displayName: "Solana Mainnet",
@@ -1488,10 +1666,12 @@ export {
   ExplorerUrls,
   KnownTokens,
   NativeTokenSol,
+  SolanaAdapter,
   SolanaExplorerMap,
   SolanaExplorerNames,
   SolanaExplorerUrls,
   SolanaExplorers,
+  SupportedX402SolanaNetworks,
   WarpSolanaConstants,
   WarpSolanaDataLoader,
   WarpSolanaExecutor,
@@ -1499,8 +1679,8 @@ export {
   WarpSolanaOutput,
   WarpSolanaSerializer,
   WarpSolanaWallet,
+  X402SolanaNetworkIdentifiers,
   findKnownTokenById,
-  getKnownTokensForChain,
-  getSolanaAdapter
+  getKnownTokensForChain
 };
 //# sourceMappingURL=index.mjs.map