@joai/warps-adapter-solana 1.0.0 → 1.0.2

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) {
@@ -947,7 +997,7 @@ var WarpSolanaOutput = class {
         output[key] = path;
       }
     }
-    return { values, output: await (0, import_warps7.evaluateOutputCommon)(warp, output, actionIndex, inputs, this.serializer.coreSerializer, this.config) };
+    return { values, output: await (0, import_warps7.evaluateOutputCommon)(warp, output, nativeValues, actionIndex, inputs, this.serializer.coreSerializer, this.config) };
   }
   async getTransactionStatus(txHash) {
     try {
@@ -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 }
@@ -1057,33 +1107,43 @@ 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 import_web34.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 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);
   }
-  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 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 {
@@ -1097,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 {
@@ -1182,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"));
@@ -1193,7 +1253,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) {
@@ -1207,13 +1267,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}}")) {
@@ -1265,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;
@@ -1295,6 +1353,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) {
@@ -1306,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);
@@ -1316,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) {
@@ -1335,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;
@@ -1391,32 +1465,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 import_web34.VersionedTransaction(messageV0);
-    if (versionedTx.version !== 0) {
-      throw new Error(`Expected VersionedTransaction v0, got version: ${versionedTx.version}`);
-    }
-    return versionedTx;
+    const messageV0 = import_web35.MessageV0.compile({
+      payerKey: fromPubkey,
+      instructions: allInstructions,
+      recentBlockhash: blockhash
+    });
+    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}`);
     }
@@ -1452,20 +1513,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) {
@@ -1477,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);
@@ -1491,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 : {};
@@ -1510,85 +1559,10 @@ 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];
   }
-  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 import_web34.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
@@ -1739,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 {
@@ -1774,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 {
@@ -1821,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(),
@@ -1832,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(),
@@ -1858,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(),
@@ -1871,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;
   }
 };
@@ -1879,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 {
@@ -1908,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 {
@@ -1956,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(),
@@ -1978,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(),
@@ -1993,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}`);
@@ -2059,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();
   }
@@ -2160,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;