@vleap/warps-adapter-solana 0.1.0-beta.6 → 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,21 +1248,24 @@ 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 { createKeyPairSignerFromBytes } from "@solana/kit";
+import { Connection as Connection6, Transaction as Transaction4, VersionedTransaction as VersionedTransaction3 } from "@solana/web3.js";
 import {
   getProviderConfig as getProviderConfig4,
   initializeWalletCache
 } from "@vleap/warps";
-import bs583 from "bs58";
+import { registerExactSvmScheme } from "@x402/svm/exact/client";
 
-// src/providers/SolanaWalletProvider.ts
-import { Keypair, Transaction as Transaction2, VersionedTransaction } from "@solana/web3.js";
+// 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";
-import { getWarpWalletMnemonicFromConfig, getWarpWalletPrivateKeyFromConfig } from "@vleap/warps";
-var SolanaWalletProvider = class {
+var MnemonicWalletProvider = class {
   constructor(config, chain, connection) {
     this.config = config;
     this.chain = chain;
@@ -1265,6 +1273,8 @@ var SolanaWalletProvider = class {
     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();
@@ -1326,50 +1336,185 @@ var SolanaWalletProvider = class {
   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
+    };
+  }
+  generate() {
+    const keypair = Keypair.generate();
+    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
+    };
+  }
   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}`);
+    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();
+    } catch {
+      return null;
+    }
+  }
+  async getPublicKey() {
+    try {
+      const keypair = this.getKeypair();
+      return keypair.publicKey.toBase58();
+    } catch {
+      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 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("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) 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");
     }
-    throw new Error("No private key or mnemonic provided");
   }
 };
 
 // src/WarpSolanaWallet.ts
 var WarpSolanaWallet = class {
-  constructor(config, chain, walletProvider) {
+  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 Connection5(providerConfig.url, "confirmed");
-    this.walletProvider = walletProvider || new SolanaWalletProvider(config, chain, this.connection);
+    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;
@@ -1378,6 +1523,7 @@ var WarpSolanaWallet = class {
   }
   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) {
@@ -1385,28 +1531,29 @@ var WarpSolanaWallet = class {
     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 VersionedTransaction2) {
+    if (tx instanceof VersionedTransaction3) {
       transaction = tx;
-    } else if (tx instanceof Transaction3) {
+    } else if (tx instanceof Transaction4) {
       transaction = tx;
     } else if (tx.transaction) {
-      if (tx.transaction instanceof Transaction3) {
+      if (tx.transaction instanceof Transaction4) {
         transaction = tx.transaction;
-      } else if (tx.transaction instanceof VersionedTransaction2) {
+      } else if (tx.transaction instanceof VersionedTransaction3) {
         transaction = tx.transaction;
       } else if (typeof tx.transaction === "object") {
         try {
-          transaction = Transaction3.from(tx.transaction);
+          transaction = Transaction4.from(tx.transaction);
         } catch {
           throw new Error("Invalid transaction format");
         }
       } else if (Buffer.isBuffer(tx.transaction) || typeof tx.transaction === "string") {
-        transaction = Transaction3.from(tx.transaction);
+        transaction = Transaction4.from(tx.transaction);
       } else {
         throw new Error("Transaction must be signed before sending");
       }
@@ -1423,23 +1570,12 @@ var WarpSolanaWallet = class {
     return Promise.all(txs.map(async (tx) => this.sendTransaction(tx)));
   }
   create(mnemonic) {
-    const seed = bip392.mnemonicToSeedSync(mnemonic);
-    const keypair = Keypair2.fromSeed(seed.slice(0, 32));
-    return {
-      address: keypair.publicKey.toBase58(),
-      privateKey: bs583.encode(keypair.secretKey),
-      mnemonic
-    };
+    if (!this.walletProvider) throw new Error("No wallet provider available");
+    return this.walletProvider.create(mnemonic);
   }
   generate() {
-    const keypair = Keypair2.generate();
-    const entropy = keypair.secretKey.slice(0, 16);
-    const mnemonic = bip392.entropyToMnemonic(entropy, wordlist);
-    return {
-      address: keypair.publicKey.toBase58(),
-      privateKey: bs583.encode(keypair.secretKey),
-      mnemonic
-    };
+    if (!this.walletProvider) throw new Error("No wallet provider available");
+    return this.walletProvider.generate();
   }
   getAddress() {
     return this.cachedAddress;
@@ -1447,6 +1583,22 @@ var WarpSolanaWallet = class {
   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 });
+      };
+    }
+    return handlers;
+  }
 };
 
 // src/chains/common.ts
@@ -1478,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",
@@ -1514,10 +1666,12 @@ export {
   ExplorerUrls,
   KnownTokens,
   NativeTokenSol,
+  SolanaAdapter,
   SolanaExplorerMap,
   SolanaExplorerNames,
   SolanaExplorerUrls,
   SolanaExplorers,
+  SupportedX402SolanaNetworks,
   WarpSolanaConstants,
   WarpSolanaDataLoader,
   WarpSolanaExecutor,
@@ -1525,8 +1679,8 @@ export {
   WarpSolanaOutput,
   WarpSolanaSerializer,
   WarpSolanaWallet,
+  X402SolanaNetworkIdentifiers,
   findKnownTokenById,
-  getKnownTokensForChain,
-  getSolanaAdapter
+  getKnownTokensForChain
 };
 //# sourceMappingURL=index.mjs.map