@joai/warps-adapter-solana 1.0.1 → 1.0.2

package/dist/index.d.cts

@@ -211,6 +211,9 @@ declare class WarpSolanaWallet implements AdapterWarpWallet {
     private initializeCache;
     private createProviderForOperation;
     private resolveTransaction;
+    private asVersionedTransaction;
+    private asVersionedTransactionOrThrow;
+    private toSerializedTransactionBytes;
     private shouldSkipPreflight;
     private sendWithRetry;
     private sendRawTransaction;

package/dist/index.d.ts

@@ -211,6 +211,9 @@ declare class WarpSolanaWallet implements AdapterWarpWallet {
     private initializeCache;
     private createProviderForOperation;
     private resolveTransaction;
+    private asVersionedTransaction;
+    private asVersionedTransactionOrThrow;
+    private toSerializedTransactionBytes;
     private shouldSkipPreflight;
     private sendWithRetry;
     private sendRawTransaction;

package/dist/index.js

@@ -57,8 +57,7 @@ var import_warps13 = require("@joai/warps");
 
 // src/WarpSolanaDataLoader.ts
 var import_warps5 = require("@joai/warps");
-var import_web3 = require("@solana/web3.js");
-var import_spl_token = require("@solana/spl-token");
+var import_web32 = require("@solana/web3.js");
 
 // src/constants.ts
 var WarpSolanaConstants = {
@@ -120,6 +119,58 @@ var X402SolanaNetworkIdentifiers = {
 };
 var SupportedX402SolanaNetworks = [X402SolanaNetworkIdentifiers.Mainnet, X402SolanaNetworkIdentifiers.Devnet];
 
+// src/tokenProgram.ts
+var import_web3 = require("@solana/web3.js");
+var MINT_SIZE = 82;
+var TOKEN_TRANSFER_INSTRUCTION = 3;
+var TOKEN_PROGRAM_ID = new import_web3.PublicKey(WarpSolanaConstants.Programs.TokenProgram);
+var ASSOCIATED_TOKEN_PROGRAM_ID = new import_web3.PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
+var getAssociatedTokenAddress = async (mint, owner, allowOwnerOffCurve = false, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) => getAssociatedTokenAddressSync(mint, owner, allowOwnerOffCurve, programId, associatedTokenProgramId);
+var getAssociatedTokenAddressSync = (mint, owner, allowOwnerOffCurve = false, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) => {
+  if (!allowOwnerOffCurve && !import_web3.PublicKey.isOnCurve(owner.toBuffer())) {
+    throw new Error("Owner cannot be a PDA");
+  }
+  const [address] = import_web3.PublicKey.findProgramAddressSync([owner.toBuffer(), programId.toBuffer(), mint.toBuffer()], associatedTokenProgramId);
+  return address;
+};
+var createAssociatedTokenAccountInstruction = (payer, associatedToken, owner, mint, programId = TOKEN_PROGRAM_ID, associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID) => new import_web3.TransactionInstruction({
+  keys: [
+    { pubkey: payer, isSigner: true, isWritable: true },
+    { pubkey: associatedToken, isSigner: false, isWritable: true },
+    { pubkey: owner, isSigner: false, isWritable: false },
+    { pubkey: mint, isSigner: false, isWritable: false },
+    { pubkey: import_web3.SystemProgram.programId, isSigner: false, isWritable: false },
+    { pubkey: programId, isSigner: false, isWritable: false }
+  ],
+  programId: associatedTokenProgramId,
+  data: Buffer.alloc(0)
+});
+var createTransferInstruction = (source, destination, owner, amount, programId = TOKEN_PROGRAM_ID) => {
+  const data = Buffer.alloc(9);
+  data.writeUInt8(TOKEN_TRANSFER_INSTRUCTION, 0);
+  data.writeBigUInt64LE(BigInt(amount), 1);
+  return new import_web3.TransactionInstruction({
+    keys: [
+      { pubkey: source, isSigner: false, isWritable: true },
+      { pubkey: destination, isSigner: false, isWritable: true },
+      { pubkey: owner, isSigner: true, isWritable: false }
+    ],
+    programId,
+    data
+  });
+};
+var getMint = async (connection, address, commitment, programId = TOKEN_PROGRAM_ID) => {
+  const info = await connection.getAccountInfo(address, commitment);
+  if (!info) throw new Error("Token mint account not found");
+  if (!info.owner.equals(programId)) throw new Error("Token mint account owner mismatch");
+  if (info.data.length < MINT_SIZE) throw new Error("Token mint account has invalid size");
+  return {
+    address,
+    decimals: info.data.readUInt8(44),
+    isInitialized: info.data.readUInt8(45) !== 0
+  };
+};
+
 // src/tokens.ts
 var import_warps4 = require("@joai/warps");
 
@@ -323,12 +374,12 @@ var WarpSolanaDataLoader = class {
     this.config = config;
     this.chain = chain;
     const providerConfig = (0, import_warps5.getProviderConfig)(this.config, this.chain.name, this.config.env, this.chain.defaultApiUrl);
-    this.connection = new import_web3.Connection(providerConfig.url, "confirmed");
+    this.connection = new import_web32.Connection(providerConfig.url, "confirmed");
     this.cache = new import_warps5.WarpCache(config.env, config.cache);
   }
   async getAccount(address) {
     try {
-      const publicKey = new import_web3.PublicKey(address);
+      const publicKey = new import_web32.PublicKey(address);
       const balance = await this.connection.getBalance(publicKey);
       return {
         chain: this.chain.name,
@@ -426,9 +477,9 @@ var WarpSolanaDataLoader = class {
   }
   async getTokenBalances(address) {
     try {
-      const publicKey = new import_web3.PublicKey(address);
+      const publicKey = new import_web32.PublicKey(address);
       const tokenAccounts = await this.connection.getParsedTokenAccountsByOwner(publicKey, {
-        programId: new import_web3.PublicKey(WarpSolanaConstants.Programs.TokenProgram)
+        programId: new import_web32.PublicKey(WarpSolanaConstants.Programs.TokenProgram)
       });
       const env = this.config.env === "mainnet" ? "mainnet" : this.config.env === "devnet" ? "devnet" : "testnet";
       const knownTokens = getKnownTokensForChain(this.chain.name, env);
@@ -470,8 +521,8 @@ var WarpSolanaDataLoader = class {
   }
   async getTokenMetadata(tokenAddress) {
     try {
-      const mintPublicKey = new import_web3.PublicKey(tokenAddress);
-      const mintInfo = await (0, import_spl_token.getMint)(this.connection, mintPublicKey);
+      const mintPublicKey = new import_web32.PublicKey(tokenAddress);
+      const mintInfo = await getMint(this.connection, mintPublicKey);
       return {
         name: "Unknown Token",
         symbol: "UNKNOWN",
@@ -620,17 +671,16 @@ var WarpSolanaDataLoader = class {
 };
 
 // src/WarpSolanaExecutor.ts
-var import_spl_token2 = require("@solana/spl-token");
-var import_web34 = require("@solana/web3.js");
+var import_web35 = require("@solana/web3.js");
 var import_warps8 = require("@joai/warps");
 
 // src/WarpSolanaOutput.ts
 var import_warps7 = require("@joai/warps");
-var import_web33 = require("@solana/web3.js");
+var import_web34 = require("@solana/web3.js");
 
 // src/WarpSolanaSerializer.ts
 var import_warps6 = require("@joai/warps");
-var import_web32 = require("@solana/web3.js");
+var import_web33 = require("@solana/web3.js");
 var import_bs58 = __toESM(require("bs58"), 1);
 var WarpSolanaSerializer = class {
   constructor() {
@@ -643,7 +693,7 @@ var WarpSolanaSerializer = class {
     if (typeof value === "string") {
       if (value.length >= 32 && value.length <= 44) {
         try {
-          const pubkey = new import_web32.PublicKey(value);
+          const pubkey = new import_web33.PublicKey(value);
           if (pubkey.toBase58() === value && /^[1-9A-HJ-NP-Za-km-z]+$/.test(value)) {
             return `address:${value}`;
           }
@@ -670,7 +720,7 @@ var WarpSolanaSerializer = class {
     if (typeof value === "boolean") {
       return `boolean:${value}`;
     }
-    if (value instanceof import_web32.PublicKey) {
+    if (value instanceof import_web33.PublicKey) {
       return `address:${value.toBase58()}`;
     }
     if (value instanceof Uint8Array) {
@@ -820,7 +870,7 @@ var WarpSolanaOutput = class {
     this.chain = chain;
     this.serializer = new WarpSolanaSerializer();
     const providerConfig = (0, import_warps7.getProviderConfig)(this.config, this.chain.name, this.config.env, this.chain.defaultApiUrl);
-    this.connection = new import_web33.Connection(providerConfig.url, "confirmed");
+    this.connection = new import_web34.Connection(providerConfig.url, "confirmed");
     this.cache = new import_warps7.WarpCache(config.env, config.cache);
   }
   async getActionExecution(warp, actionIndex, tx) {
@@ -996,7 +1046,7 @@ var WarpSolanaExecutor = class {
     this.chain = chain;
     this.serializer = new WarpSolanaSerializer();
     const providerConfig = (0, import_warps8.getProviderConfig)(this.config, chain.name, this.config.env, this.chain.defaultApiUrl);
-    this.connection = new import_web34.Connection(providerConfig.url, "confirmed");
+    this.connection = new import_web35.Connection(providerConfig.url, "confirmed");
     this.output = new WarpSolanaOutput(config, this.chain);
   }
   async createTransaction(executable) {
@@ -1025,14 +1075,14 @@ var WarpSolanaExecutor = class {
     }
     const instructions = [];
     if (executable.value > 0n) {
-      instructions.push(import_web34.SystemProgram.transfer({ fromPubkey, toPubkey: destinationPubkey, lamports: Number(executable.value) }));
+      instructions.push(import_web35.SystemProgram.transfer({ fromPubkey, toPubkey: destinationPubkey, lamports: Number(executable.value) }));
     }
     if (executable.data) {
       const data = this.serializer.stringToTyped(executable.data);
       if (data && typeof data === "string") {
         const dataBuffer = Buffer.from(data, "base64");
         instructions.push(
-          new import_web34.TransactionInstruction({
+          new import_web35.TransactionInstruction({
             keys: [
               { pubkey: fromPubkey, isSigner: true, isWritable: true },
               { pubkey: destinationPubkey, isSigner: false, isWritable: true }
@@ -1061,9 +1111,9 @@ var WarpSolanaExecutor = class {
     const abiAccounts = parsedAbi?.instructions?.[action.func]?.accounts ?? null;
     const accounts = await this.buildInstructionAccounts(action, executable, fromPubkey, programId, abiAccounts);
     await this.ensureATAs(abiAccounts, accounts, fromPubkey, instructions);
-    instructions.push(new import_web34.TransactionInstruction({ keys: accounts, programId, data: instructionData }));
+    instructions.push(new import_web35.TransactionInstruction({ keys: accounts, programId, data: instructionData }));
     if (executable.value > 0n) {
-      instructions.push(import_web34.SystemProgram.transfer({ fromPubkey, toPubkey: programId, lamports: Number(executable.value) }));
+      instructions.push(import_web35.SystemProgram.transfer({ fromPubkey, toPubkey: programId, lamports: Number(executable.value) }));
     }
     return this.setTransactionDefaults(instructions, fromPubkey);
   }
@@ -1086,14 +1136,14 @@ var WarpSolanaExecutor = class {
         if (match) {
           const mintAddress = match[1];
           try {
-            const mintPubkey = new import_web34.PublicKey(mintAddress);
-            const expectedAta = await (0, import_spl_token2.getAssociatedTokenAddress)(mintPubkey, fromPubkey);
+            const mintPubkey = new import_web35.PublicKey(mintAddress);
+            const expectedAta = await getAssociatedTokenAddress(mintPubkey, fromPubkey);
             const ataKey = expectedAta.toBase58();
             if (!createdATAs.has(ataKey)) {
               createdATAs.add(ataKey);
               const ataInfo = await this.connection.getAccountInfo(expectedAta);
               if (!ataInfo) {
-                instructions.push((0, import_spl_token2.createAssociatedTokenAccountInstruction)(fromPubkey, expectedAta, fromPubkey, mintPubkey));
+                instructions.push(createAssociatedTokenAccountInstruction(fromPubkey, expectedAta, fromPubkey, mintPubkey));
               }
             }
           } catch {
@@ -1107,15 +1157,15 @@ var WarpSolanaExecutor = class {
           const mintAddress = match[1];
           const receiverAddress = match[2];
           try {
-            const mintPubkey = new import_web34.PublicKey(mintAddress);
-            const receiverPubkey = new import_web34.PublicKey(receiverAddress);
-            const expectedAta = await (0, import_spl_token2.getAssociatedTokenAddress)(mintPubkey, receiverPubkey);
+            const mintPubkey = new import_web35.PublicKey(mintAddress);
+            const receiverPubkey = new import_web35.PublicKey(receiverAddress);
+            const expectedAta = await getAssociatedTokenAddress(mintPubkey, receiverPubkey);
             const ataKey = expectedAta.toBase58();
             if (!createdATAs.has(ataKey)) {
               createdATAs.add(ataKey);
               const ataInfo = await this.connection.getAccountInfo(expectedAta);
               if (!ataInfo) {
-                instructions.push((0, import_spl_token2.createAssociatedTokenAccountInstruction)(fromPubkey, expectedAta, receiverPubkey, mintPubkey));
+                instructions.push(createAssociatedTokenAccountInstruction(fromPubkey, expectedAta, receiverPubkey, mintPubkey));
               }
             }
           } catch {
@@ -1192,7 +1242,7 @@ var WarpSolanaExecutor = class {
         buffers.push(Buffer.from(String(arg), "utf8"));
       } else if (def.type === "publicKey" || def.type === "pubkey") {
         try {
-          const pubkey = new import_web34.PublicKey(arg);
+          const pubkey = new import_web35.PublicKey(arg);
           buffers.push(Buffer.from(pubkey.toBuffer()));
         } catch {
           buffers.push(Buffer.from(String(arg), "utf8"));
@@ -1273,7 +1323,7 @@ var WarpSolanaExecutor = class {
     if (accountInput.input.as?.startsWith("USER_ATA:") || accountInput.input.as?.startsWith("RECEIVER_ATA:")) {
       return await this.resolveAccountPubkey(`{{${accountInput.input.as}}}`, fromPubkey);
     }
-    return new import_web34.PublicKey(address);
+    return new import_web35.PublicKey(address);
   }
   interpolateAccountAddress(address, resolvedInputs) {
     if (!address.includes("{{")) return address;
@@ -1330,8 +1380,8 @@ var WarpSolanaExecutor = class {
     if (nativeTokenTransfers.length === 1 && splTokenTransfers.length === 0) {
       const transfer = nativeTokenTransfers[0];
       if (transfer.amount <= 0n) throw new Error("WarpSolanaExecutor: Native token transfer amount must be positive");
-      const fromPubkey = new import_web34.PublicKey(userWallet);
-      return this.setTransactionDefaults([import_web34.SystemProgram.transfer({ fromPubkey, toPubkey: destinationPubkey, lamports: Number(transfer.amount) })], fromPubkey);
+      const fromPubkey = new import_web35.PublicKey(userWallet);
+      return this.setTransactionDefaults([import_web35.SystemProgram.transfer({ fromPubkey, toPubkey: destinationPubkey, lamports: Number(transfer.amount) })], fromPubkey);
     }
     if (nativeTokenTransfers.length === 0 && splTokenTransfers.length === 1) {
       return this.createSingleTokenTransfer(executable, splTokenTransfers[0], userWallet, destinationPubkey);
@@ -1340,18 +1390,18 @@ var WarpSolanaExecutor = class {
     throw new Error("WarpSolanaExecutor: Invalid transfer configuration");
   }
   async createSingleTokenTransfer(executable, transfer, userWallet, destinationPubkey) {
-    const mintAddress = new import_web34.PublicKey(transfer.identifier);
-    const fromPubkey = new import_web34.PublicKey(userWallet);
-    const sourceTokenAccount = await (0, import_spl_token2.getAssociatedTokenAddress)(mintAddress, fromPubkey);
-    const destinationTokenAccount = await (0, import_spl_token2.getAssociatedTokenAddress)(mintAddress, destinationPubkey);
+    const mintAddress = new import_web35.PublicKey(transfer.identifier);
+    const fromPubkey = new import_web35.PublicKey(userWallet);
+    const sourceTokenAccount = await getAssociatedTokenAddress(mintAddress, fromPubkey);
+    const destinationTokenAccount = await getAssociatedTokenAddress(mintAddress, destinationPubkey);
     if (!await this.connection.getAccountInfo(sourceTokenAccount)) {
       throw new Error("WarpSolanaExecutor: Source token account does not exist");
     }
     const instructions = [];
     if (!await this.connection.getAccountInfo(destinationTokenAccount)) {
-      instructions.push((0, import_spl_token2.createAssociatedTokenAccountInstruction)(fromPubkey, destinationTokenAccount, destinationPubkey, mintAddress));
+      instructions.push(createAssociatedTokenAccountInstruction(fromPubkey, destinationTokenAccount, destinationPubkey, mintAddress));
     }
-    instructions.push((0, import_spl_token2.createTransferInstruction)(sourceTokenAccount, destinationTokenAccount, fromPubkey, Number(transfer.amount)));
+    instructions.push(createTransferInstruction(sourceTokenAccount, destinationTokenAccount, fromPubkey, Number(transfer.amount)));
     return this.setTransactionDefaults(instructions, fromPubkey);
   }
   async executeQuery(executable) {
@@ -1359,7 +1409,7 @@ var WarpSolanaExecutor = class {
     if (action.type !== "query") throw new Error(`WarpSolanaExecutor: Invalid action type for executeQuery: ${action.type}`);
     if (!action.func) throw new Error("WarpSolanaExecutor: Query action must have a function name");
     if (!executable.destination) throw new Error("WarpSolanaExecutor: Query address is required");
-    const queryAddress = new import_web34.PublicKey(executable.destination);
+    const queryAddress = new import_web35.PublicKey(executable.destination);
     const nativeArgs = executable.args.map((arg) => this.serializer.coreSerializer.stringToNative(arg)[1]);
     let decodedResult = [];
     let isSuccess = true;
@@ -1418,16 +1468,16 @@ var WarpSolanaExecutor = class {
   async setTransactionDefaults(instructions, fromPubkey) {
     const { blockhash } = await this.connection.getLatestBlockhash("confirmed");
     const allInstructions = this.addComputeBudgetInstructions(instructions);
-    const messageV0 = import_web34.MessageV0.compile({
+    const messageV0 = import_web35.MessageV0.compile({
       payerKey: fromPubkey,
       instructions: allInstructions,
       recentBlockhash: blockhash
     });
-    return new import_web34.VersionedTransaction(messageV0);
+    return new import_web35.VersionedTransaction(messageV0);
   }
   toPublicKey(address, errorMsg) {
     try {
-      return new import_web34.PublicKey(address);
+      return new import_web35.PublicKey(address);
     } catch {
       throw new Error(`WarpSolanaExecutor: ${errorMsg}`);
     }
@@ -1476,8 +1526,8 @@ var WarpSolanaExecutor = class {
       if (!mintAddress || mintAddress.includes("{{")) {
         throw new Error(`Invalid USER_ATA placeholder: ${address}. Mint address must be resolved first.`);
       }
-      const mintPubkey = new import_web34.PublicKey(mintAddress);
-      return await (0, import_spl_token2.getAssociatedTokenAddress)(mintPubkey, fromPubkey);
+      const mintPubkey = new import_web35.PublicKey(mintAddress);
+      return await getAssociatedTokenAddress(mintPubkey, fromPubkey);
     }
     if (address.startsWith("{{RECEIVER_ATA:") && address.endsWith("}}")) {
       const content = address.slice(15, -2);
@@ -1490,12 +1540,12 @@ var WarpSolanaExecutor = class {
         }
         if (mintAddress.includes(":")) mintAddress = mintAddress.split(":")[1];
         if (receiverAddress.includes(":")) receiverAddress = receiverAddress.split(":")[1];
-        const mintPubkey = new import_web34.PublicKey(mintAddress);
-        const receiverPubkey = new import_web34.PublicKey(receiverAddress);
-        return await (0, import_spl_token2.getAssociatedTokenAddress)(mintPubkey, receiverPubkey);
+        const mintPubkey = new import_web35.PublicKey(mintAddress);
+        const receiverPubkey = new import_web35.PublicKey(receiverAddress);
+        return await getAssociatedTokenAddress(mintPubkey, receiverPubkey);
       }
     }
-    return new import_web34.PublicKey(address);
+    return new import_web35.PublicKey(address);
   }
   determineAccountFlags(accountDef, pubkey, fromPubkey) {
     const accountMeta = typeof accountDef === "object" ? accountDef : {};
@@ -1509,8 +1559,8 @@ var WarpSolanaExecutor = class {
   addComputeBudgetInstructions(instructions) {
     const hasTokenTransfer = instructions.some((ix) => ix.programId.toBase58() === WarpSolanaConstants.Programs.TokenProgram);
     const computeUnits = hasTokenTransfer ? WarpSolanaConstants.ComputeUnitLimit.TokenTransfer : WarpSolanaConstants.ComputeUnitLimit.Default;
-    const computeUnitLimitIx = import_web34.ComputeBudgetProgram.setComputeUnitLimit({ units: computeUnits });
-    const computeUnitPriceIx = import_web34.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: WarpSolanaConstants.PriorityFee.Default });
+    const computeUnitLimitIx = import_web35.ComputeBudgetProgram.setComputeUnitLimit({ units: computeUnits });
+    const computeUnitPriceIx = import_web35.ComputeBudgetProgram.setComputeUnitPrice({ microLamports: WarpSolanaConstants.PriorityFee.Default });
     return [computeUnitLimitIx, computeUnitPriceIx, ...instructions];
   }
 };
@@ -1663,13 +1713,13 @@ var WarpSolanaExplorer = class {
 // src/WarpSolanaWallet.ts
 var import_warps12 = require("@joai/warps");
 var import_kit = require("@solana/kit");
-var import_web37 = require("@solana/web3.js");
+var import_web38 = require("@solana/web3.js");
 var import_client = require("@x402/svm/exact/client");
 
 // src/providers/MnemonicWalletProvider.ts
 var bip39 = __toESM(require("@scure/bip39"), 1);
 var import_english = require("@scure/bip39/wordlists/english.js");
-var import_web35 = require("@solana/web3.js");
+var import_web36 = require("@solana/web3.js");
 var import_warps9 = require("@joai/warps");
 var import_bs582 = __toESM(require("bs58"), 1);
 var _MnemonicWalletProvider = class _MnemonicWalletProvider {
@@ -1698,22 +1748,22 @@ var _MnemonicWalletProvider = class _MnemonicWalletProvider {
   }
   async signTransaction(tx) {
     const keypair = this.getKeypair();
-    if (tx instanceof import_web35.VersionedTransaction) {
+    if (tx instanceof import_web36.VersionedTransaction) {
       tx.sign([keypair]);
       return tx;
     }
-    if (tx instanceof import_web35.Transaction) {
+    if (tx instanceof import_web36.Transaction) {
       tx.sign(keypair);
       return tx;
     }
     if (tx.transaction) {
-      if (tx.transaction instanceof import_web35.Transaction) {
+      if (tx.transaction instanceof import_web36.Transaction) {
         tx.transaction.sign(keypair);
         return { ...tx, transaction: tx.transaction.serialize() };
       }
       if (typeof tx.transaction === "object") {
         try {
-          const transaction = import_web35.Transaction.from(tx.transaction);
+          const transaction = import_web36.Transaction.from(tx.transaction);
           transaction.sign(keypair);
           return { ...tx, transaction: transaction.serialize(), signature: transaction.signature };
         } catch {
@@ -1745,7 +1795,7 @@ var _MnemonicWalletProvider = class _MnemonicWalletProvider {
   async importFromMnemonic(mnemonic) {
     const trimmedMnemonic = (0, import_warps9.normalizeAndValidateMnemonic)(mnemonic);
     const seed = bip39.mnemonicToSeedSync(trimmedMnemonic);
-    const keypair = import_web35.Keypair.fromSeed(seed.slice(0, 32));
+    const keypair = import_web36.Keypair.fromSeed(seed.slice(0, 32));
     const walletDetails = {
       provider: _MnemonicWalletProvider.PROVIDER_NAME,
       address: keypair.publicKey.toBase58(),
@@ -1756,7 +1806,7 @@ var _MnemonicWalletProvider = class _MnemonicWalletProvider {
     return walletDetails;
   }
   async importFromPrivateKey(privateKey) {
-    const keypair = import_web35.Keypair.fromSecretKey(import_bs582.default.decode(privateKey));
+    const keypair = import_web36.Keypair.fromSecretKey(import_bs582.default.decode(privateKey));
     const walletDetails = {
       provider: _MnemonicWalletProvider.PROVIDER_NAME,
       address: keypair.publicKey.toBase58(),
@@ -1782,7 +1832,7 @@ var _MnemonicWalletProvider = class _MnemonicWalletProvider {
     const mnemonic = (0, import_warps9.normalizeMnemonic)(mnemonicRaw);
     (0, import_warps9.validateMnemonicLength)(mnemonic);
     const seed = bip39.mnemonicToSeedSync(mnemonic);
-    const keypair = import_web35.Keypair.fromSeed(seed.slice(0, 32));
+    const keypair = import_web36.Keypair.fromSeed(seed.slice(0, 32));
     return {
       provider: _MnemonicWalletProvider.PROVIDER_NAME,
       address: keypair.publicKey.toBase58(),
@@ -1795,7 +1845,7 @@ var _MnemonicWalletProvider = class _MnemonicWalletProvider {
     const mnemonic = (0, import_warps9.getWarpWalletMnemonicFromConfig)(this.config, this.chain.name);
     if (!mnemonic) throw new Error("No mnemonic provided");
     const seed = bip39.mnemonicToSeedSync(mnemonic);
-    this.keypair = import_web35.Keypair.fromSeed(seed.slice(0, 32));
+    this.keypair = import_web36.Keypair.fromSeed(seed.slice(0, 32));
     return this.keypair;
   }
 };
@@ -1803,7 +1853,7 @@ _MnemonicWalletProvider.PROVIDER_NAME = "mnemonic";
 var MnemonicWalletProvider = _MnemonicWalletProvider;
 
 // src/providers/PrivateKeyWalletProvider.ts
-var import_web36 = require("@solana/web3.js");
+var import_web37 = require("@solana/web3.js");
 var import_warps10 = require("@joai/warps");
 var import_bs583 = __toESM(require("bs58"), 1);
 var _PrivateKeyWalletProvider = class _PrivateKeyWalletProvider {
@@ -1832,22 +1882,22 @@ var _PrivateKeyWalletProvider = class _PrivateKeyWalletProvider {
   }
   async signTransaction(tx) {
     const keypair = this.getKeypair();
-    if (tx instanceof import_web36.VersionedTransaction) {
+    if (tx instanceof import_web37.VersionedTransaction) {
       tx.sign([keypair]);
       return tx;
     }
-    if (tx instanceof import_web36.Transaction) {
+    if (tx instanceof import_web37.Transaction) {
       tx.sign(keypair);
       return tx;
     }
     if (tx.transaction) {
-      if (tx.transaction instanceof import_web36.Transaction) {
+      if (tx.transaction instanceof import_web37.Transaction) {
         tx.transaction.sign(keypair);
         return { ...tx, transaction: tx.transaction.serialize() };
       }
       if (typeof tx.transaction === "object") {
         try {
-          const transaction = import_web36.Transaction.from(tx.transaction);
+          const transaction = import_web37.Transaction.from(tx.transaction);
           transaction.sign(keypair);
           return { ...tx, transaction: transaction.serialize(), signature: transaction.signature };
         } catch {
@@ -1880,7 +1930,7 @@ var _PrivateKeyWalletProvider = class _PrivateKeyWalletProvider {
     throw new Error("PrivateKeyWalletProvider does not support importing from mnemonics. Use MnemonicWalletProvider instead.");
   }
   async importFromPrivateKey(privateKey) {
-    const keypair = import_web36.Keypair.fromSecretKey(import_bs583.default.decode(privateKey));
+    const keypair = import_web37.Keypair.fromSecretKey(import_bs583.default.decode(privateKey));
     const walletDetails = {
       provider: _PrivateKeyWalletProvider.PROVIDER_NAME,
       address: keypair.publicKey.toBase58(),
@@ -1902,7 +1952,7 @@ var _PrivateKeyWalletProvider = class _PrivateKeyWalletProvider {
     };
   }
   async generate() {
-    const keypair = import_web36.Keypair.generate();
+    const keypair = import_web37.Keypair.generate();
     return {
       provider: _PrivateKeyWalletProvider.PROVIDER_NAME,
       address: keypair.publicKey.toBase58(),
@@ -1917,10 +1967,10 @@ var _PrivateKeyWalletProvider = class _PrivateKeyWalletProvider {
     try {
       const secretKey = import_bs583.default.decode(privateKey);
       if (secretKey.length === 64) {
-        this.keypair = import_web36.Keypair.fromSecretKey(secretKey);
+        this.keypair = import_web37.Keypair.fromSecretKey(secretKey);
         return this.keypair;
       } else if (secretKey.length === 32) {
-        this.keypair = import_web36.Keypair.fromSeed(secretKey);
+        this.keypair = import_web37.Keypair.fromSeed(secretKey);
         return this.keypair;
       } else {
         throw new Error(`Invalid private key length: expected 32 or 64 bytes, got ${secretKey.length}`);
@@ -1983,7 +2033,7 @@ var WarpSolanaWallet = class {
     this.cachedAddress = null;
     this.cachedPublicKey = null;
     const providerConfig = (0, import_warps12.getProviderConfig)(config, chain.name, config.env, chain.defaultApiUrl);
-    this.connection = new import_web37.Connection(providerConfig.url, "confirmed");
+    this.connection = new import_web38.Connection(providerConfig.url, "confirmed");
     this.walletProvider = this.createProvider();
     this.initializeCache();
   }
@@ -2084,29 +2134,51 @@ var WarpSolanaWallet = class {
     throw new Error(`Unsupported wallet provider for ${this.chain.name}: ${provider}`);
   }
   resolveTransaction(tx) {
-    if (tx instanceof import_web37.VersionedTransaction) {
-      if (tx.version === void 0 || tx.version === "legacy") {
-        throw new Error("Transaction must be a VersionedTransaction (v0), not legacy");
-      }
-      return tx;
+    const directVersionedTransaction = this.asVersionedTransaction(tx);
+    if (directVersionedTransaction) return directVersionedTransaction;
+    if (tx instanceof import_web38.Transaction) {
+      throw new Error("Legacy Transaction format is not supported. All transactions must use VersionedTransaction (v0).");
     }
-    if (tx instanceof import_web37.Transaction) {
+    const nestedTransaction = tx.transaction;
+    const nestedVersionedTransaction = this.asVersionedTransaction(nestedTransaction);
+    if (nestedVersionedTransaction) return nestedVersionedTransaction;
+    if (nestedTransaction instanceof import_web38.Transaction) {
       throw new Error("Legacy Transaction format is not supported. All transactions must use VersionedTransaction (v0).");
     }
-    if (tx.transaction instanceof import_web37.VersionedTransaction) {
-      if (tx.transaction.version === void 0 || tx.transaction.version === "legacy") {
-        throw new Error("Transaction must be a VersionedTransaction (v0), not legacy");
+    const serializedTransaction = this.toSerializedTransactionBytes(nestedTransaction);
+    if (serializedTransaction) {
+      try {
+        return this.asVersionedTransactionOrThrow(import_web38.VersionedTransaction.deserialize(serializedTransaction));
+      } catch {
+        throw new Error("Invalid serialized transaction format. Expected a VersionedTransaction payload.");
       }
-      return tx.transaction;
-    }
-    if (tx.transaction instanceof import_web37.Transaction) {
-      throw new Error("Legacy Transaction format is not supported. All transactions must use VersionedTransaction (v0).");
     }
-    if (!tx.transaction) {
+    if (!nestedTransaction) {
       throw new Error("Transaction must be signed before sending");
     }
     throw new Error("Invalid transaction format - only VersionedTransaction is supported");
   }
+  asVersionedTransaction(tx) {
+    if (!(tx instanceof import_web38.VersionedTransaction)) return null;
+    return this.asVersionedTransactionOrThrow(tx);
+  }
+  asVersionedTransactionOrThrow(tx) {
+    if (tx.version === void 0 || tx.version === "legacy") {
+      throw new Error("Transaction must be a VersionedTransaction (v0), not legacy");
+    }
+    return tx;
+  }
+  toSerializedTransactionBytes(value) {
+    if (value instanceof Uint8Array) return value;
+    if (typeof Buffer !== "undefined" && Buffer.isBuffer(value)) return new Uint8Array(value);
+    if (Array.isArray(value) && value.every((byte) => Number.isInteger(byte) && byte >= 0 && byte <= 255)) {
+      return Uint8Array.from(value);
+    }
+    if (typeof value === "string" && value.trim() !== "") {
+      return Uint8Array.from(Buffer.from(value.trim(), "base64"));
+    }
+    return null;
+  }
   async shouldSkipPreflight(transaction) {
     if (!transaction.signatures || transaction.signatures.length === 0 || !transaction.signatures.some((sig) => sig.some((b) => b !== 0))) {
       return false;