@joai/warps-adapter-solana 1.0.0 → 1.0.2

package/dist/index.mjs

@@ -9,8 +9,7 @@ import {
   WarpCache,
   WarpCacheKey
 } from "@joai/warps";
-import { Connection, PublicKey } from "@solana/web3.js";
-import { getMint } from "@solana/spl-token";
+import { Connection as Connection2, PublicKey as PublicKey2 } from "@solana/web3.js";
 
 // src/constants.ts
 var WarpSolanaConstants = {
@@ -72,6 +71,58 @@ var X402SolanaNetworkIdentifiers = {
 };
 var SupportedX402SolanaNetworks = [X402SolanaNetworkIdentifiers.Mainnet, X402SolanaNetworkIdentifiers.Devnet];
 
+// src/tokenProgram.ts
+import { PublicKey, SystemProgram, TransactionInstruction } from "@solana/web3.js";
+var MINT_SIZE = 82;
+var TOKEN_TRANSFER_INSTRUCTION = 3;
+var TOKEN_PROGRAM_ID = new PublicKey(WarpSolanaConstants.Programs.TokenProgram);
+var ASSOCIATED_TOKEN_PROGRAM_ID = new 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 && !PublicKey.isOnCurve(owner.toBuffer())) {
+    throw new Error("Owner cannot be a PDA");
+  }
+  const [address] = 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 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: 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 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
 import { WarpChainName as WarpChainName4 } from "@joai/warps";
 
@@ -275,12 +326,12 @@ var WarpSolanaDataLoader = class {
     this.config = config;
     this.chain = chain;
     const providerConfig = getProviderConfig(this.config, this.chain.name, this.config.env, this.chain.defaultApiUrl);
-    this.connection = new Connection(providerConfig.url, "confirmed");
+    this.connection = new Connection2(providerConfig.url, "confirmed");
     this.cache = new WarpCache(config.env, config.cache);
   }
   async getAccount(address) {
     try {
-      const publicKey = new PublicKey(address);
+      const publicKey = new PublicKey2(address);
       const balance = await this.connection.getBalance(publicKey);
       return {
         chain: this.chain.name,
@@ -378,9 +429,9 @@ var WarpSolanaDataLoader = class {
   }
   async getTokenBalances(address) {
     try {
-      const publicKey = new PublicKey(address);
+      const publicKey = new PublicKey2(address);
       const tokenAccounts = await this.connection.getParsedTokenAccountsByOwner(publicKey, {
-        programId: new PublicKey(WarpSolanaConstants.Programs.TokenProgram)
+        programId: new PublicKey2(WarpSolanaConstants.Programs.TokenProgram)
       });
       const env = this.config.env === "mainnet" ? "mainnet" : this.config.env === "devnet" ? "devnet" : "testnet";
       const knownTokens = getKnownTokensForChain(this.chain.name, env);
@@ -422,7 +473,7 @@ var WarpSolanaDataLoader = class {
   }
   async getTokenMetadata(tokenAddress) {
     try {
-      const mintPublicKey = new PublicKey(tokenAddress);
+      const mintPublicKey = new PublicKey2(tokenAddress);
       const mintInfo = await getMint(this.connection, mintPublicKey);
       return {
         name: "Unknown Token",
@@ -572,8 +623,7 @@ var WarpSolanaDataLoader = class {
 };
 
 // src/WarpSolanaExecutor.ts
-import { createAssociatedTokenAccountInstruction, createTransferInstruction, getAssociatedTokenAddress } from "@solana/spl-token";
-import { ComputeBudgetProgram, Connection as Connection3, MessageV0, PublicKey as PublicKey3, SystemProgram, TransactionInstruction, VersionedTransaction } from "@solana/web3.js";
+import { ComputeBudgetProgram, Connection as Connection4, MessageV0, PublicKey as PublicKey4, SystemProgram as SystemProgram2, TransactionInstruction as TransactionInstruction2, VersionedTransaction } from "@solana/web3.js";
 import {
   applyOutputToMessages,
   extractResolvedInputValues as extractResolvedInputValues2,
@@ -594,14 +644,14 @@ import {
   WarpCache as WarpCache2,
   WarpCacheKey as WarpCacheKey2
 } from "@joai/warps";
-import { Connection as Connection2 } from "@solana/web3.js";
+import { Connection as Connection3 } from "@solana/web3.js";
 
 // src/WarpSolanaSerializer.ts
 import {
   WarpConstants,
   WarpSerializer
 } from "@joai/warps";
-import { PublicKey as PublicKey2 } from "@solana/web3.js";
+import { PublicKey as PublicKey3 } from "@solana/web3.js";
 import bs58 from "bs58";
 var WarpSolanaSerializer = class {
   constructor() {
@@ -614,7 +664,7 @@ var WarpSolanaSerializer = class {
     if (typeof value === "string") {
       if (value.length >= 32 && value.length <= 44) {
         try {
-          const pubkey = new PublicKey2(value);
+          const pubkey = new PublicKey3(value);
           if (pubkey.toBase58() === value && /^[1-9A-HJ-NP-Za-km-z]+$/.test(value)) {
             return `address:${value}`;
           }
@@ -641,7 +691,7 @@ var WarpSolanaSerializer = class {
     if (typeof value === "boolean") {
       return `boolean:${value}`;
     }
-    if (value instanceof PublicKey2) {
+    if (value instanceof PublicKey3) {
       return `address:${value.toBase58()}`;
     }
     if (value instanceof Uint8Array) {
@@ -791,7 +841,7 @@ var WarpSolanaOutput = class {
     this.chain = chain;
     this.serializer = new WarpSolanaSerializer();
     const providerConfig = getProviderConfig2(this.config, this.chain.name, this.config.env, this.chain.defaultApiUrl);
-    this.connection = new Connection2(providerConfig.url, "confirmed");
+    this.connection = new Connection3(providerConfig.url, "confirmed");
     this.cache = new WarpCache2(config.env, config.cache);
   }
   async getActionExecution(warp, actionIndex, tx) {
@@ -918,7 +968,7 @@ var WarpSolanaOutput = class {
         output[key] = path;
       }
     }
-    return { values, output: await evaluateOutputCommon(warp, output, actionIndex, inputs, this.serializer.coreSerializer, this.config) };
+    return { values, output: await evaluateOutputCommon(warp, output, nativeValues, actionIndex, inputs, this.serializer.coreSerializer, this.config) };
   }
   async getTransactionStatus(txHash) {
     try {
@@ -967,7 +1017,7 @@ var WarpSolanaExecutor = class {
     this.chain = chain;
     this.serializer = new WarpSolanaSerializer();
     const providerConfig = getProviderConfig3(this.config, chain.name, this.config.env, this.chain.defaultApiUrl);
-    this.connection = new Connection3(providerConfig.url, "confirmed");
+    this.connection = new Connection4(providerConfig.url, "confirmed");
     this.output = new WarpSolanaOutput(config, this.chain);
   }
   async createTransaction(executable) {
@@ -996,14 +1046,14 @@ var WarpSolanaExecutor = class {
     }
     const instructions = [];
     if (executable.value > 0n) {
-      instructions.push(SystemProgram.transfer({ fromPubkey, toPubkey: destinationPubkey, lamports: Number(executable.value) }));
+      instructions.push(SystemProgram2.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 TransactionInstruction({
+          new TransactionInstruction2({
             keys: [
               { pubkey: fromPubkey, isSigner: true, isWritable: true },
               { pubkey: destinationPubkey, isSigner: false, isWritable: true }
@@ -1028,26 +1078,36 @@ var WarpSolanaExecutor = class {
     const argsToUse = this.extractContractArgs(executable);
     const nativeArgs = argsToUse.map((arg) => this.serializer.coreSerializer.stringToNative(arg)[1]);
     const instructionData = this.buildInstructionData(action, nativeArgs);
-    const accounts = await this.buildInstructionAccounts(action, executable, fromPubkey, programId);
-    await this.ensureATAs(action, accounts, fromPubkey, instructions);
-    instructions.push(new TransactionInstruction({ keys: accounts, programId, data: instructionData }));
+    const parsedAbi = this.parseAbi(action);
+    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 TransactionInstruction2({ keys: accounts, programId, data: instructionData }));
     if (executable.value > 0n) {
-      instructions.push(SystemProgram.transfer({ fromPubkey, toPubkey: programId, lamports: Number(executable.value) }));
+      instructions.push(SystemProgram2.transfer({ fromPubkey, toPubkey: programId, lamports: Number(executable.value) }));
     }
     return this.setTransactionDefaults(instructions, fromPubkey);
   }
-  async ensureATAs(action, accounts, fromPubkey, instructions) {
-    if (!action.accounts || !Array.isArray(action.accounts)) return;
+  parseAbi(action) {
+    if (!action.abi || typeof action.abi !== "string") return null;
+    try {
+      return JSON.parse(action.abi);
+    } catch {
+      return null;
+    }
+  }
+  async ensureATAs(abiAccounts, accounts, fromPubkey, instructions) {
+    if (!abiAccounts || !Array.isArray(abiAccounts)) return;
     const createdATAs = /* @__PURE__ */ new Set();
-    for (let idx = 0; idx < action.accounts.length; idx++) {
-      const accountDef = action.accounts[idx];
+    for (let idx = 0; idx < abiAccounts.length; idx++) {
+      const accountDef = abiAccounts[idx];
       const accountStr = typeof accountDef === "string" ? accountDef : JSON.stringify(accountDef);
       if (accountStr.includes("{{USER_ATA:")) {
         const match = accountStr.match(/USER_ATA[:\s]*([^"}\s]+)/);
         if (match) {
           const mintAddress = match[1];
           try {
-            const mintPubkey = new PublicKey3(mintAddress);
+            const mintPubkey = new PublicKey4(mintAddress);
             const expectedAta = await getAssociatedTokenAddress(mintPubkey, fromPubkey);
             const ataKey = expectedAta.toBase58();
             if (!createdATAs.has(ataKey)) {
@@ -1068,8 +1128,8 @@ var WarpSolanaExecutor = class {
           const mintAddress = match[1];
           const receiverAddress = match[2];
           try {
-            const mintPubkey = new PublicKey3(mintAddress);
-            const receiverPubkey = new PublicKey3(receiverAddress);
+            const mintPubkey = new PublicKey4(mintAddress);
+            const receiverPubkey = new PublicKey4(receiverAddress);
             const expectedAta = await getAssociatedTokenAddress(mintPubkey, receiverPubkey);
             const ataKey = expectedAta.toBase58();
             if (!createdATAs.has(ataKey)) {
@@ -1153,7 +1213,7 @@ var WarpSolanaExecutor = class {
         buffers.push(Buffer.from(String(arg), "utf8"));
       } else if (def.type === "publicKey" || def.type === "pubkey") {
         try {
-          const pubkey = new PublicKey3(arg);
+          const pubkey = new PublicKey4(arg);
           buffers.push(Buffer.from(pubkey.toBuffer()));
         } catch {
           buffers.push(Buffer.from(String(arg), "utf8"));
@@ -1164,7 +1224,7 @@ var WarpSolanaExecutor = class {
     }
     return Buffer.concat(buffers);
   }
-  async buildInstructionAccounts(action, executable, fromPubkey, programId) {
+  async buildInstructionAccounts(action, executable, fromPubkey, programId, abiAccounts) {
     const accounts = [];
     const accountInputs = this.extractAccountInputs(action, executable);
     if (accountInputs.length > 0) {
@@ -1178,13 +1238,11 @@ var WarpSolanaExecutor = class {
       }
       return accounts;
     }
-    if (!action.accounts || !Array.isArray(action.accounts)) return accounts;
-    for (let idx = 0; idx < action.accounts.length; idx++) {
-      const accountDef = action.accounts[idx];
+    if (!abiAccounts || !Array.isArray(abiAccounts)) return accounts;
+    for (let idx = 0; idx < abiAccounts.length; idx++) {
+      const accountDef = abiAccounts[idx];
       let address = this.extractAccountAddress(accountDef);
-      if (address === "[object Object]" || typeof accountDef === "string" && accountDef === "[object Object]") {
-        address = fromPubkey.toBase58();
-      } else if (!address || address.length === 0) {
+      if (!address || address.length === 0) {
         throw new Error(`Invalid account definition at index ${idx}: ${JSON.stringify(accountDef)}`);
       }
       if (address === "{{USER_WALLET}}" || typeof address === "string" && address.includes("{{USER_WALLET}}")) {
@@ -1236,7 +1294,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 PublicKey3(address);
+    return new PublicKey4(address);
   }
   interpolateAccountAddress(address, resolvedInputs) {
     if (!address.includes("{{")) return address;
@@ -1266,6 +1324,22 @@ var WarpSolanaExecutor = class {
         }
       }
     }
+    if (address.includes("{{USER_ATA:") || address.includes("{{RECEIVER_ATA:")) {
+      for (const resolved of resolvedInputs) {
+        if (!resolved.input?.as) continue;
+        const key = resolved.input.as.toUpperCase();
+        if (address.includes(key)) {
+          let value = resolved.value;
+          if (typeof value === "string" && value.includes(":")) {
+            value = value.split(":")[1];
+          }
+          if (value) {
+            address = address.replace(new RegExp(key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), String(value));
+          }
+        }
+      }
+      return address;
+    }
     return address;
   }
   async createTokenTransferTransaction(executable, userWallet, destinationPubkey) {
@@ -1277,8 +1351,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 PublicKey3(userWallet);
-      return this.setTransactionDefaults([SystemProgram.transfer({ fromPubkey, toPubkey: destinationPubkey, lamports: Number(transfer.amount) })], fromPubkey);
+      const fromPubkey = new PublicKey4(userWallet);
+      return this.setTransactionDefaults([SystemProgram2.transfer({ fromPubkey, toPubkey: destinationPubkey, lamports: Number(transfer.amount) })], fromPubkey);
     }
     if (nativeTokenTransfers.length === 0 && splTokenTransfers.length === 1) {
       return this.createSingleTokenTransfer(executable, splTokenTransfers[0], userWallet, destinationPubkey);
@@ -1287,8 +1361,8 @@ var WarpSolanaExecutor = class {
     throw new Error("WarpSolanaExecutor: Invalid transfer configuration");
   }
   async createSingleTokenTransfer(executable, transfer, userWallet, destinationPubkey) {
-    const mintAddress = new PublicKey3(transfer.identifier);
-    const fromPubkey = new PublicKey3(userWallet);
+    const mintAddress = new PublicKey4(transfer.identifier);
+    const fromPubkey = new PublicKey4(userWallet);
     const sourceTokenAccount = await getAssociatedTokenAddress(mintAddress, fromPubkey);
     const destinationTokenAccount = await getAssociatedTokenAddress(mintAddress, destinationPubkey);
     if (!await this.connection.getAccountInfo(sourceTokenAccount)) {
@@ -1306,7 +1380,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 PublicKey3(executable.destination);
+    const queryAddress = new PublicKey4(executable.destination);
     const nativeArgs = executable.args.map((arg) => this.serializer.coreSerializer.stringToNative(arg)[1]);
     let decodedResult = [];
     let isSuccess = true;
@@ -1362,32 +1436,19 @@ var WarpSolanaExecutor = class {
       resolvedInputs
     };
   }
-  async verifyMessage(message, signature) {
-    try {
-      const messageBytes = new TextEncoder().encode(message);
-      const signatureBytes = Buffer.from(signature, "base64");
-      return "";
-    } catch (error) {
-      throw new Error(`Failed to verify message: ${error}`);
-    }
-  }
   async setTransactionDefaults(instructions, fromPubkey) {
     const { blockhash } = await this.connection.getLatestBlockhash("confirmed");
     const allInstructions = this.addComputeBudgetInstructions(instructions);
-    const accountMetaMap = this.buildAccountMetaMap(allInstructions, fromPubkey);
-    const { signedAccounts, unsignedAccounts } = this.sortAccounts(accountMetaMap);
-    const { staticAccountKeys, accountIndexMap } = this.buildAccountIndexMap(signedAccounts, unsignedAccounts);
-    const compiledInstructions = this.compileInstructions(allInstructions, accountIndexMap);
-    const messageV0 = this.buildMessageV0(blockhash, signedAccounts, unsignedAccounts, accountMetaMap, staticAccountKeys, compiledInstructions);
-    const versionedTx = new VersionedTransaction(messageV0);
-    if (versionedTx.version !== 0) {
-      throw new Error(`Expected VersionedTransaction v0, got version: ${versionedTx.version}`);
-    }
-    return versionedTx;
+    const messageV0 = MessageV0.compile({
+      payerKey: fromPubkey,
+      instructions: allInstructions,
+      recentBlockhash: blockhash
+    });
+    return new VersionedTransaction(messageV0);
   }
   toPublicKey(address, errorMsg) {
     try {
-      return new PublicKey3(address);
+      return new PublicKey4(address);
     } catch {
       throw new Error(`WarpSolanaExecutor: ${errorMsg}`);
     }
@@ -1423,20 +1484,8 @@ var WarpSolanaExecutor = class {
   extractAccountAddress(accountDef) {
     if (typeof accountDef === "string") return accountDef;
     if (!accountDef || typeof accountDef !== "object") return void 0;
-    const str = JSON.stringify(accountDef);
-    if (str.includes("USER_WALLET") || str.includes("{{USER_WALLET}}")) return "{{USER_WALLET}}";
-    if (str.includes("RECEIVER_ADDRESS") || str.includes("{{RECEIVER_ADDRESS}}")) return "{{RECEIVER_ADDRESS}}";
-    if (str.includes("USER_ATA")) {
-      const match = str.match(/USER_ATA[:\s]*([^"}\s]+)/);
-      if (match) return `{{USER_ATA:${match[1]}}}`;
-    }
-    const addrValue = accountDef.address || accountDef.pubkey || accountDef.value;
-    if (typeof addrValue === "string") return addrValue;
-    if (addrValue?.toBase58) return addrValue.toBase58();
-    if (addrValue?.identifier) return addrValue.identifier;
-    if (addrValue?.value) return addrValue.value;
-    const keys = Object.keys(accountDef);
-    if (keys.length === 1 && typeof accountDef[keys[0]] === "string") return accountDef[keys[0]];
+    const address = accountDef.address || accountDef.pubkey;
+    if (typeof address === "string") return address;
     return void 0;
   }
   async resolveAccountPubkey(address, fromPubkey) {
@@ -1448,7 +1497,7 @@ var WarpSolanaExecutor = class {
       if (!mintAddress || mintAddress.includes("{{")) {
         throw new Error(`Invalid USER_ATA placeholder: ${address}. Mint address must be resolved first.`);
       }
-      const mintPubkey = new PublicKey3(mintAddress);
+      const mintPubkey = new PublicKey4(mintAddress);
       return await getAssociatedTokenAddress(mintPubkey, fromPubkey);
     }
     if (address.startsWith("{{RECEIVER_ATA:") && address.endsWith("}}")) {
@@ -1462,12 +1511,12 @@ var WarpSolanaExecutor = class {
         }
         if (mintAddress.includes(":")) mintAddress = mintAddress.split(":")[1];
         if (receiverAddress.includes(":")) receiverAddress = receiverAddress.split(":")[1];
-        const mintPubkey = new PublicKey3(mintAddress);
-        const receiverPubkey = new PublicKey3(receiverAddress);
+        const mintPubkey = new PublicKey4(mintAddress);
+        const receiverPubkey = new PublicKey4(receiverAddress);
         return await getAssociatedTokenAddress(mintPubkey, receiverPubkey);
       }
     }
-    return new PublicKey3(address);
+    return new PublicKey4(address);
   }
   determineAccountFlags(accountDef, pubkey, fromPubkey) {
     const accountMeta = typeof accountDef === "object" ? accountDef : {};
@@ -1485,81 +1534,6 @@ var WarpSolanaExecutor = class {
     const computeUnitPriceIx = ComputeBudgetProgram.setComputeUnitPrice({ microLamports: WarpSolanaConstants.PriorityFee.Default });
     return [computeUnitLimitIx, computeUnitPriceIx, ...instructions];
   }
-  buildAccountMetaMap(instructions, fromPubkey) {
-    const accountMetaMap = /* @__PURE__ */ new Map();
-    if (fromPubkey) {
-      accountMetaMap.set(fromPubkey.toBase58(), { pubkey: fromPubkey, isSigner: true, isWritable: true });
-    }
-    for (const ix of instructions) {
-      const programIdStr = ix.programId.toBase58();
-      if (!accountMetaMap.has(programIdStr)) {
-        accountMetaMap.set(programIdStr, { pubkey: ix.programId, isSigner: false, isWritable: false });
-      }
-      for (const key of ix.keys) {
-        const keyStr = key.pubkey.toBase58();
-        const existing = accountMetaMap.get(keyStr);
-        if (existing) {
-          accountMetaMap.set(keyStr, {
-            pubkey: key.pubkey,
-            isSigner: existing.isSigner || key.isSigner,
-            isWritable: existing.isWritable || key.isWritable
-          });
-        } else {
-          accountMetaMap.set(keyStr, {
-            pubkey: key.pubkey,
-            isSigner: key.isSigner,
-            isWritable: key.isWritable
-          });
-        }
-      }
-    }
-    return accountMetaMap;
-  }
-  sortAccounts(accountMetaMap) {
-    const signedAccounts = [];
-    const unsignedAccounts = [];
-    for (const meta of accountMetaMap.values()) {
-      ;
-      (meta.isSigner ? signedAccounts : unsignedAccounts).push(meta.pubkey);
-    }
-    const sortByWritable = (a, b) => (accountMetaMap.get(a.toBase58()).isWritable ? 0 : 1) - (accountMetaMap.get(b.toBase58()).isWritable ? 0 : 1);
-    signedAccounts.sort(sortByWritable);
-    unsignedAccounts.sort(sortByWritable);
-    return { signedAccounts, unsignedAccounts };
-  }
-  buildAccountIndexMap(signedAccounts, unsignedAccounts) {
-    const staticAccountKeys = [...signedAccounts, ...unsignedAccounts];
-    const accountIndexMap = /* @__PURE__ */ new Map();
-    staticAccountKeys.forEach((key, index) => {
-      accountIndexMap.set(key.toBase58(), index);
-    });
-    return { staticAccountKeys, accountIndexMap };
-  }
-  compileInstructions(instructions, accountIndexMap) {
-    return instructions.map((ix) => {
-      const programIdIndex = accountIndexMap.get(ix.programId.toBase58());
-      const accountKeyIndexes = ix.keys.map((key) => accountIndexMap.get(key.pubkey.toBase58()));
-      return {
-        programIdIndex,
-        accountKeyIndexes,
-        data: Uint8Array.from(ix.data)
-      };
-    });
-  }
-  buildMessageV0(blockhash, signedAccounts, unsignedAccounts, accountMetaMap, staticAccountKeys, compiledInstructions) {
-    const getWritable = (key) => accountMetaMap.get(key.toBase58()).isWritable;
-    return new MessageV0({
-      header: {
-        numRequiredSignatures: signedAccounts.length,
-        numReadonlySignedAccounts: signedAccounts.filter((k) => !getWritable(k)).length,
-        numReadonlyUnsignedAccounts: unsignedAccounts.filter((k) => !getWritable(k)).length
-      },
-      staticAccountKeys,
-      recentBlockhash: blockhash,
-      compiledInstructions,
-      addressTableLookups: []
-    });
-  }
 };
 
 // src/WarpSolanaExplorer.ts
@@ -1713,7 +1687,7 @@ import {
   initializeWalletCache
 } from "@joai/warps";
 import { createKeyPairSignerFromBytes } from "@solana/kit";
-import { Connection as Connection4, Transaction as Transaction3, VersionedTransaction as VersionedTransaction4 } from "@solana/web3.js";
+import { Connection as Connection5, Transaction as Transaction3, VersionedTransaction as VersionedTransaction4 } from "@solana/web3.js";
 import { registerExactSvmScheme } from "@x402/svm/exact/client";
 
 // src/providers/MnemonicWalletProvider.ts
@@ -2046,7 +2020,7 @@ var WarpSolanaWallet = class {
     this.cachedAddress = null;
     this.cachedPublicKey = null;
     const providerConfig = getProviderConfig4(config, chain.name, config.env, chain.defaultApiUrl);
-    this.connection = new Connection4(providerConfig.url, "confirmed");
+    this.connection = new Connection5(providerConfig.url, "confirmed");
     this.walletProvider = this.createProvider();
     this.initializeCache();
   }
@@ -2147,29 +2121,51 @@ var WarpSolanaWallet = class {
     throw new Error(`Unsupported wallet provider for ${this.chain.name}: ${provider}`);
   }
   resolveTransaction(tx) {
-    if (tx instanceof VersionedTransaction4) {
-      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 Transaction3) {
       throw new Error("Legacy Transaction format is not supported. All transactions must use VersionedTransaction (v0).");
     }
-    if (tx.transaction instanceof VersionedTransaction4) {
-      if (tx.transaction.version === void 0 || tx.transaction.version === "legacy") {
-        throw new Error("Transaction must be a VersionedTransaction (v0), not legacy");
-      }
-      return tx.transaction;
-    }
-    if (tx.transaction instanceof Transaction3) {
+    const nestedTransaction = tx.transaction;
+    const nestedVersionedTransaction = this.asVersionedTransaction(nestedTransaction);
+    if (nestedVersionedTransaction) return nestedVersionedTransaction;
+    if (nestedTransaction instanceof Transaction3) {
       throw new Error("Legacy Transaction format is not supported. All transactions must use VersionedTransaction (v0).");
     }
-    if (!tx.transaction) {
+    const serializedTransaction = this.toSerializedTransactionBytes(nestedTransaction);
+    if (serializedTransaction) {
+      try {
+        return this.asVersionedTransactionOrThrow(VersionedTransaction4.deserialize(serializedTransaction));
+      } catch {
+        throw new Error("Invalid serialized transaction format. Expected a VersionedTransaction payload.");
+      }
+    }
+    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 VersionedTransaction4)) 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;