@joai/warps-adapter-solana 1.0.0 → 1.0.1

package/dist/index.mjs

@@ -918,7 +918,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 {
@@ -1028,19 +1028,29 @@ 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);
+    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 TransactionInstruction({ keys: accounts, programId, data: instructionData }));
     if (executable.value > 0n) {
       instructions.push(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]+)/);
@@ -1164,7 +1174,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 +1188,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}}")) {
@@ -1266,6 +1274,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) {
@@ -1362,28 +1386,15 @@ 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 {
@@ -1423,20 +1434,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) {
@@ -1485,81 +1484,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