@pioneer-platform/pioneer-sdk 8.12.0 → 8.12.4

package/dist/index.js

@@ -1250,17 +1250,17 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
     let unsignedTx;
     if (memo === " ")
       memo = "";
+    const isThorchainSwap = memo && (memo.startsWith("=") || memo.startsWith("SWAP") || memo.includes(":"));
     switch (assetType) {
       case "gas": {
-        const isThorchainOperation = memo && (memo.startsWith("=") || memo.startsWith("SWAP") || memo.includes(":"));
         let gasLimit;
-        if (isThorchainOperation) {
-          gasLimit = BigInt(120000);
+        if (isThorchainSwap) {
+          gasLimit = BigInt(1e5);
           console.log(tag, "Using higher gas limit for THORChain swap:", gasLimit.toString());
         } else {
           gasLimit = chainId === 1 ? BigInt(21000) : BigInt(25000);
         }
-        if (memo && memo !== "" && !isThorchainOperation) {
+        if (memo && memo !== "" && !isThorchainSwap) {
           const memoBytes = Buffer.from(memo, "utf8").length;
           gasLimit += BigInt(memoBytes) * 68n;
         }
@@ -1275,11 +1275,30 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
           console.log(tag, "isMax calculation - balance:", balance.toString(), "gasFee:", gasFee.toString(), "buffer:", buffer.toString(), "amountWei:", amountWei.toString());
         } else {
           amountWei = BigInt(Math.round(amount * 1000000000000000000));
-          if (amountWei + gasFee > balance) {
-            throw new Error("Insufficient funds for the transaction amount and gas fees");
+          const totalNeeded = amountWei + gasFee;
+          if (totalNeeded > balance) {
+            const availableForSwap = balance > gasFee ? balance - gasFee : 0n;
+            const balanceEth2 = (Number(balance) / 1000000000000000000).toFixed(6);
+            const amountEth = (Number(amountWei) / 1000000000000000000).toFixed(6);
+            const gasFeeEth = (Number(gasFee) / 1000000000000000000).toFixed(6);
+            const availableEth = (Number(availableForSwap) / 1000000000000000000).toFixed(6);
+            const swapType = isThorchainSwap ? "THORChain swap" : "transfer";
+            throw new Error(`Insufficient funds for the transaction amount and gas fees.
+` + `Balance: ${balanceEth2} ETH
+` + `Attempting to ${swapType}: ${amountEth} ETH
+` + `Estimated gas fee: ${gasFeeEth} ETH (${gasLimit.toString()} gas limit)
+` + `Total needed: ${(Number(totalNeeded) / 1000000000000000000).toFixed(6)} ETH
+` + `Maximum swappable: ${availableEth} ETH (after gas fees)`);
           }
         }
-        const isThorchainSwap = memo && (memo.startsWith("=") || memo.startsWith("SWAP") || memo.includes(":"));
+        console.log(tag, "Transaction calculation:", {
+          balance: balance.toString() + " wei (" + (Number(balance) / 1000000000000000000).toFixed(6) + " ETH)",
+          amountWei: amountWei.toString() + " wei (" + (Number(amountWei) / 1000000000000000000).toFixed(6) + " ETH)",
+          gasFee: gasFee.toString() + " wei (" + (Number(gasFee) / 1000000000000000000).toFixed(6) + " ETH)",
+          gasLimit: gasLimit.toString(),
+          gasPrice: gasPrice.toString() + " wei (" + (Number(gasPrice) / 1e9).toFixed(2) + " gwei)",
+          isThorchainSwap
+        });
         let txData = "0x";
         if (isThorchainSwap) {
           console.log(tag, "Detected THORChain swap, encoding deposit data for memo:", memo);
@@ -1301,14 +1320,25 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
               const inboundResponse = await fetch("https://thornode.ninerealms.com/thorchain/inbound_addresses");
               if (inboundResponse.ok) {
                 const inboundData = await inboundResponse.json();
-                const ethInbound = inboundData.find((inbound) => inbound.chain === "ETH" && !inbound.halted);
-                if (ethInbound) {
-                  vaultAddress = ethInbound.address;
-                  routerAddress = ethInbound.router || to;
+                const chainIdToThorchain = {
+                  1: "ETH",
+                  43114: "AVAX",
+                  8453: "BASE",
+                  56: "BSC"
+                };
+                const thorchainName = chainIdToThorchain[chainId];
+                if (!thorchainName) {
+                  throw new Error(`Unsupported chain ID for THORChain swap: ${chainId}`);
+                }
+                console.log(tag, "Looking for THORChain inbound for chain:", thorchainName, "chainId:", chainId);
+                const chainInbound = inboundData.find((inbound) => inbound.chain === thorchainName && !inbound.halted);
+                if (chainInbound) {
+                  vaultAddress = chainInbound.address;
+                  routerAddress = chainInbound.router || to;
                   console.log(tag, "Using THORChain inbound addresses - vault:", vaultAddress, "router:", routerAddress);
                   to = routerAddress;
                 } else {
-                  throw new Error("ETH inbound is halted or not found - cannot proceed with swap");
+                  throw new Error(`${thorchainName} inbound is halted or not found - cannot proceed with swap`);
                 }
               }
             } catch (fetchError) {
@@ -1318,6 +1348,15 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
             if (vaultAddress === "0x0000000000000000000000000000000000000000") {
               throw new Error("Cannot proceed with THORChain swap - vault address is invalid (0x0)");
             }
+            if (to.toLowerCase() === vaultAddress.toLowerCase()) {
+              console.warn(tag, '⚠️  WARNING: "to" address equals vault address - this should be the router!');
+              console.warn(tag, "⚠️  Using fetched router address instead:", routerAddress);
+              to = routerAddress;
+            }
+            if (!/^0x[a-fA-F0-9]{40}$/.test(to)) {
+              throw new Error(`Invalid router address format: ${to}`);
+            }
+            console.log(tag, "✅ Final validation passed - router:", to, "vault:", vaultAddress);
             const functionSelector = "44bc937b";
             const assetAddress = "0x0000000000000000000000000000000000000000";
             const expiryTime = Math.floor(Date.now() / 1000) + 3600;
@@ -1406,17 +1445,98 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
         if (estimatedGasFee > balance) {
           throw new Error("Insufficient ETH balance to cover gas fees");
         }
-        const data = encodeTransferData(to, amountWei);
+        let data;
+        let finalTo;
+        if (isThorchainSwap) {
+          console.log(tag, "\uD83D\uDD04 ERC20 THORChain swap detected - encoding depositWithExpiry");
+          let vaultAddress = "0x0000000000000000000000000000000000000000";
+          let routerAddress = to;
+          try {
+            const inboundResponse = await fetch("https://thornode.ninerealms.com/thorchain/inbound_addresses");
+            if (inboundResponse.ok) {
+              const inboundData = await inboundResponse.json();
+              const chainIdToThorchain = {
+                1: "ETH",
+                43114: "AVAX",
+                8453: "BASE",
+                56: "BSC"
+              };
+              const thorchainName = chainIdToThorchain[chainId];
+              if (!thorchainName) {
+                throw new Error(`Unsupported chain ID for THORChain swap: ${chainId}`);
+              }
+              console.log(tag, "Looking for THORChain inbound for chain:", thorchainName, "chainId:", chainId);
+              const chainInbound = inboundData.find((inbound) => inbound.chain === thorchainName && !inbound.halted);
+              if (chainInbound) {
+                vaultAddress = chainInbound.address;
+                routerAddress = chainInbound.router || to;
+                console.log(tag, "Using THORChain inbound addresses - vault:", vaultAddress, "router:", routerAddress);
+                to = routerAddress;
+              } else {
+                throw new Error(`${thorchainName} inbound is halted or not found - cannot proceed with swap`);
+              }
+            }
+          } catch (fetchError) {
+            console.error(tag, "Failed to fetch inbound addresses:", fetchError);
+            throw new Error(`Cannot proceed with THORChain swap - failed to fetch inbound addresses: ${fetchError.message}`);
+          }
+          if (vaultAddress === "0x0000000000000000000000000000000000000000") {
+            throw new Error("Cannot proceed with THORChain swap - vault address is invalid (0x0)");
+          }
+          if (to.toLowerCase() === vaultAddress.toLowerCase()) {
+            console.warn(tag, '⚠️  WARNING: "to" address equals vault address - this should be the router!');
+            console.warn(tag, "⚠️  Using fetched router address instead:", routerAddress);
+            to = routerAddress;
+          }
+          if (!/^0x[a-fA-F0-9]{40}$/.test(to)) {
+            throw new Error(`Invalid router address format: ${to}`);
+          }
+          console.log(tag, "✅ Final validation passed - router:", to, "vault:", vaultAddress);
+          console.log(tag, "✅ ERC20 THORChain swap addresses validated");
+          console.log(tag, "   Router:", to);
+          console.log(tag, "   Vault:", vaultAddress);
+          console.log(tag, "   Token:", contractAddress);
+          const functionSelector = "44bc937b";
+          const expiryTime = Math.floor(Date.now() / 1000) + 3600;
+          const vaultPadded = vaultAddress.toLowerCase().replace(/^0x/, "").padStart(64, "0");
+          const assetPadded = contractAddress.toLowerCase().replace(/^0x/, "").padStart(64, "0");
+          const amountPadded = amountWei.toString(16).padStart(64, "0");
+          const stringOffset = (5 * 32).toString(16).padStart(64, "0");
+          const expiryPadded = expiryTime.toString(16).padStart(64, "0");
+          const fixedMemo = memo || "";
+          const memoBytes = Buffer.from(fixedMemo, "utf8");
+          const memoHex = memoBytes.toString("hex");
+          const stringLength = memoBytes.length.toString(16).padStart(64, "0");
+          const paddingLength = (32 - memoBytes.length % 32) % 32;
+          const memoPadded = memoHex + "0".repeat(paddingLength * 2);
+          data = "0x" + functionSelector + vaultPadded + assetPadded + amountPadded + stringOffset + expiryPadded + stringLength + memoPadded;
+          finalTo = to;
+          console.log(tag, "✅ Encoded ERC20 depositWithExpiry:", {
+            functionSelector: "0x" + functionSelector,
+            vault: vaultAddress,
+            asset: contractAddress,
+            amount: amountWei.toString(),
+            memo: fixedMemo,
+            expiry: expiryTime,
+            dataLength: data.length
+          });
+          gasLimit = BigInt(200000);
+        } else {
+          data = encodeTransferData(to, amountWei);
+          finalTo = contractAddress;
+        }
         const ethPriceInUsd = await fetchEthPriceInUsd(pioneer, networkId);
-        const gasFeeUsd = Number(gasFee) / 1000000000000000000 * ethPriceInUsd;
+        const finalGasFee = gasPrice * gasLimit;
+        const gasFeeUsd = Number(finalGasFee) / 1000000000000000000 * ethPriceInUsd;
         const tokenPriceInUsd = await fetchTokenPriceInUsd(pioneer, caip);
         const amountUsd = Number(amountWei) / Number(tokenMultiplier) * tokenPriceInUsd;
         unsignedTx = {
           chainId,
+          from: address,
           nonce: toHex(nonce),
           gas: toHex(gasLimit),
           gasPrice: toHex(gasPrice),
-          to: contractAddress,
+          to: finalTo,
           value: "0x0",
           data,
           gasFeeUsd,
@@ -4276,8 +4396,58 @@ class SDK {
           if (tx.type === "deposit") {
             unsignedTx = await createUnsignedTendermintTx(caip, tx.type, tx.txParams.amount, tx.txParams.memo, this.pubkeys, this.pioneer, this.pubkeyContext, false, undefined);
           } else if (tx.type === "EVM" || tx.type === "evm") {
-            console.log(tag, "Using pre-built EVM transaction from integration");
-            unsignedTx = tx.txParams;
+            console.log(tag, "Building EVM swap transaction with createUnsignedEvmTx");
+            unsignedTx = await createUnsignedEvmTx(caip, tx.txParams.recipientAddress, parseFloat(tx.txParams.amount), tx.txParams.memo, this.pubkeys, this.pioneer, this.pubkeyContext, false);
+            console.log(tag, "✅ Built complete EVM transaction:", {
+              to: unsignedTx.to,
+              from: this.pubkeyContext?.address,
+              value: unsignedTx.value,
+              chainId: unsignedTx.chainId,
+              hasData: !!unsignedTx.data
+            });
+            console.log(tag, "\uD83D\uDEE1️  Running Tenderly simulation for EVM swap...");
+            try {
+              const insightResult = await this.pioneer.Insight({
+                tx: unsignedTx,
+                source: "swap",
+                isThorchainSwap: tx.txParams.isThorchainSwap || false
+              });
+              const insight = insightResult.body;
+              console.log(tag, "Simulation result:", insight?.simulation);
+              if (!insight || !insight.simulation) {
+                console.warn(tag, "⚠️  WARNING: Tenderly simulation unavailable - proceeding without validation");
+              } else if (!insight.simulation.success) {
+                console.warn(tag, `⚠️  WARNING: Swap simulation FAILED - ${insight.simulation.error || "Transaction may revert"}`);
+                console.warn(tag, "⚠️  Proceeding anyway - USE CAUTION");
+              } else {
+                if (tx.txParams.isThorchainSwap) {
+                  console.log(tag, "\uD83D\uDD0D Verifying THORChain swap parameters...");
+                  const method = insight.simulation.method;
+                  if (!method || !method.toLowerCase().includes("deposit")) {
+                    throw new Error(`❌ CRITICAL: Invalid THORChain swap method: ${method} - expected depositWithExpiry`);
+                  }
+                  const routerAddress = unsignedTx.to;
+                  const vaultAddress = tx.txParams.vaultAddress;
+                  if (routerAddress && vaultAddress) {
+                    if (routerAddress.toLowerCase() === vaultAddress.toLowerCase()) {
+                      throw new Error(`❌ CRITICAL: Sending directly to vault ${vaultAddress} instead of router!`);
+                    }
+                    console.log(tag, `✅ Router: ${routerAddress}`);
+                    console.log(tag, `✅ Vault: ${vaultAddress}`);
+                  }
+                  if (insight.simulation.addresses && insight.simulation.addresses.length > 0) {
+                    console.log(tag, `✅ Addresses involved: ${insight.simulation.addresses.length}`);
+                  } else {
+                    console.log(tag, "⚠️  WARNING: No addresses detected in simulation");
+                  }
+                }
+                console.log(tag, `✅ Simulation PASSED - Gas used: ${insight.simulation.gasUsed}`);
+                console.log(tag, `✅ Method: ${insight.simulation.method}`);
+              }
+            } catch (e) {
+              console.error(tag, "❌ Simulation validation failed:", e.message);
+              throw new Error(`Swap blocked by simulation failure: ${e.message}`);
+            }
           } else {
             if (!tx.txParams.memo)
               throw Error("memo required on swaps!");
@@ -5147,6 +5317,30 @@ class SDK {
       }
     };
   }
+  CheckERC20Allowance = async (params) => {
+    const tag = TAG9 + " | CheckERC20Allowance | ";
+    try {
+      console.log(tag, "Checking ERC20 allowance:", params);
+      const result = await this.pioneer.GetTokenAllowance(params);
+      console.log(tag, "Allowance result:", result);
+      return result.data;
+    } catch (e) {
+      console.error(tag, "Error checking ERC20 allowance:", e);
+      throw e;
+    }
+  };
+  BuildERC20ApprovalTx = async (params) => {
+    const tag = TAG9 + " | BuildERC20ApprovalTx | ";
+    try {
+      console.log(tag, "Building ERC20 approval transaction:", params);
+      const result = await this.pioneer.BuildApprovalTransaction(params);
+      console.log(tag, "Approval tx built:", result);
+      return result.data;
+    } catch (e) {
+      console.error(tag, "Error building approval transaction:", e);
+      throw e;
+    }
+  };
 }
 var src_default = SDK;
 export {

package/package.json

@@ -1,7 +1,7 @@
 {
   "author": "highlander",
   "name": "@pioneer-platform/pioneer-sdk",
-  "version": "8.12.0",
+  "version": "8.12.4",
   "dependencies": {
     "@keepkey/keepkey-sdk": "^0.2.62",
     "@pioneer-platform/loggerdog": "^8.11.0",

package/src/index.ts

@@ -13,6 +13,7 @@ import { optimizedGetPubkeys } from './kkapi-batch-client.js';
 import { OfflineClient } from './offline-client.js';
 import { TransactionManager } from './TransactionManager.js';
 import { createUnsignedTendermintTx } from './txbuilder/createUnsignedTendermintTx.js';
+import { createUnsignedEvmTx } from './txbuilder/createUnsignedEvmTx.js';
 import { createUnsignedStakingTx, type StakingTxParams } from './txbuilder/createUnsignedStakingTx.js';
 import { getFees, estimateTransactionFee, type NormalizedFeeRates, type FeeEstimate } from './fees/index.js';
 // Utils
@@ -1303,9 +1304,101 @@ export class SDK {
               undefined,
             );
           } else if (tx.type === 'EVM' || tx.type === 'evm') {
-            //EVM transaction - use the pre-built transaction from integration
-            console.log(tag, 'Using pre-built EVM transaction from integration');
-            unsignedTx = tx.txParams;
+            //EVM transaction - build complete transaction using createUnsignedEvmTx
+            console.log(tag, 'Building EVM swap transaction with createUnsignedEvmTx');
+
+            // The THORChain integration provides:
+            // - recipientAddress: router address (where to send the transaction)
+            // - amount: amount to swap
+            // - memo: THORChain swap memo
+            // - vaultAddress: vault address (encoded in the transaction data by createUnsignedEvmTx)
+            // - isThorchainSwap: flag indicating this is a THORChain swap
+
+            unsignedTx = await createUnsignedEvmTx(
+              caip,
+              tx.txParams.recipientAddress, // Router address from THORChain
+              parseFloat(tx.txParams.amount),
+              tx.txParams.memo,
+              this.pubkeys,
+              this.pioneer,
+              this.pubkeyContext,
+              false, // isMax
+            );
+
+            console.log(tag, '✅ Built complete EVM transaction:', {
+              to: unsignedTx.to,
+              from: this.pubkeyContext?.address,
+              value: unsignedTx.value,
+              chainId: unsignedTx.chainId,
+              hasData: !!unsignedTx.data,
+            });
+
+            // CRITICAL: Simulate EVM swap before signing
+            console.log(tag, '🛡️  Running Tenderly simulation for EVM swap...');
+            try {
+              // Call insight API for simulation using proper Swagger operation
+              const insightResult = await this.pioneer.Insight({
+                tx: unsignedTx,
+                source: 'swap',
+                isThorchainSwap: tx.txParams.isThorchainSwap || false,
+              });
+
+              const insight = insightResult.body;
+              console.log(tag, 'Simulation result:', insight?.simulation);
+
+              // WARN if Tenderly is offline or unavailable (but don't block)
+              if (!insight || !insight.simulation) {
+                console.warn(tag, '⚠️  WARNING: Tenderly simulation unavailable - proceeding without validation');
+              } else if (!insight.simulation.success) {
+                // WARN if simulation failed (but don't block)
+                console.warn(
+                  tag,
+                  `⚠️  WARNING: Swap simulation FAILED - ${insight.simulation.error || 'Transaction may revert'}`,
+                );
+                console.warn(tag, '⚠️  Proceeding anyway - USE CAUTION');
+              } else {
+
+              // Verify swap parameters for THORChain
+              if (tx.txParams.isThorchainSwap) {
+                console.log(tag, '🔍 Verifying THORChain swap parameters...');
+
+                // Verify method is depositWithExpiry or similar
+                const method = insight.simulation.method;
+                if (!method || !method.toLowerCase().includes('deposit')) {
+                  throw new Error(
+                    `❌ CRITICAL: Invalid THORChain swap method: ${method} - expected depositWithExpiry`,
+                  );
+                }
+
+                // Verify router address is being called (not vault directly)
+                const routerAddress = unsignedTx.to;
+                const vaultAddress = tx.txParams.vaultAddress;
+
+                if (routerAddress && vaultAddress) {
+                  if (routerAddress.toLowerCase() === vaultAddress.toLowerCase()) {
+                    throw new Error(
+                      `❌ CRITICAL: Sending directly to vault ${vaultAddress} instead of router!`,
+                    );
+                  }
+                  console.log(tag, `✅ Router: ${routerAddress}`);
+                  console.log(tag, `✅ Vault: ${vaultAddress}`);
+                }
+
+                // Verify addresses involved in simulation
+                if (insight.simulation.addresses && insight.simulation.addresses.length > 0) {
+                  console.log(tag, `✅ Addresses involved: ${insight.simulation.addresses.length}`);
+                } else {
+                  console.log(tag, '⚠️  WARNING: No addresses detected in simulation');
+                }
+              }
+
+              console.log(tag, `✅ Simulation PASSED - Gas used: ${insight.simulation.gasUsed}`);
+              console.log(tag, `✅ Method: ${insight.simulation.method}`);
+              }
+            } catch (e: any) {
+              console.error(tag, '❌ Simulation validation failed:', e.message);
+              throw new Error(`Swap blocked by simulation failure: ${e.message}`);
+            }
           } else {
             //transfer transaction (UTXO chains) - requires memo
             if (!tx.txParams.memo) throw Error('memo required on swaps!');
@@ -2531,6 +2624,55 @@ export class SDK {
       }
     };
   }
+
+  /**
+   * Check ERC20 token allowance for a spender
+   * Used to verify if approval is needed before THORChain swaps
+   */
+  public CheckERC20Allowance = async (params: {
+    networkId: string;
+    contractAddress: string;
+    ownerAddress: string;
+    spenderAddress: string;
+  }) => {
+    const tag = TAG + ' | CheckERC20Allowance | ';
+    try {
+      console.log(tag, 'Checking ERC20 allowance:', params);
+
+      const result = await this.pioneer.GetTokenAllowance(params);
+
+      console.log(tag, 'Allowance result:', result);
+      return result.data;
+    } catch (e) {
+      console.error(tag, 'Error checking ERC20 allowance:', e);
+      throw e;
+    }
+  };
+
+  /**
+   * Build an ERC20 approval transaction
+   * Required before THORChain router can transfer tokens
+   */
+  public BuildERC20ApprovalTx = async (params: {
+    networkId: string;
+    contractAddress: string;
+    spenderAddress: string;
+    ownerAddress: string;
+    amount: string;
+  }) => {
+    const tag = TAG + ' | BuildERC20ApprovalTx | ';
+    try {
+      console.log(tag, 'Building ERC20 approval transaction:', params);
+
+      const result = await this.pioneer.BuildApprovalTransaction(params);
+
+      console.log(tag, 'Approval tx built:', result);
+      return result.data;
+    } catch (e) {
+      console.error(tag, 'Error building approval transaction:', e);
+      throw e;
+    }
+  };
 }
 
 // Export fee-related types for consumers