@pioneer-platform/pioneer-sdk 8.12.0 → 8.12.4

package/src/txbuilder/createUnsignedEvmTx.ts

@@ -104,6 +104,14 @@ async function fetchTokenPriceInUsd(pioneer: any, caip: string) {
 }
 
 // Create an unsigned EVM transaction
+/**
+ * Create an unsigned EVM transaction
+ *
+ * @param feeLevel - Fee speed preference:
+ *   - 1-2: Slow (80% of base gas price)
+ *   - 3-7: Average (100% of base gas price) [DEFAULT: 5]
+ *   - 8-10: Fast (150% of base gas price)
+ */
 export async function createUnsignedEvmTx(
   caip,
   to,
@@ -113,7 +121,7 @@ export async function createUnsignedEvmTx(
   pioneer,
   pubkeyContext,
   isMax,
-  feeLevel = 5, // Added feeLevel parameter with default of 5 (average)
+  feeLevel = 5, // Default: average fee level (100% of base)
 ) {
   const tag = TAG + ' | createUnsignedEvmTx | ';
 
@@ -281,18 +289,20 @@ export async function createUnsignedEvmTx(
 
     if (memo === ' ') memo = '';
 
+    // Check if this is a THORChain swap (memo starts with '=' or 'SWAP' or contains ':')
+    // Define this before the switch so it's available in all cases
+    const isThorchainSwap =
+      memo && (memo.startsWith('=') || memo.startsWith('SWAP') || memo.includes(':'));
+
     // Build transaction object based on asset type
     switch (assetType) {
       case 'gas': {
-        // Check if this is a THORChain swap (needs more gas for contract call)
-        const isThorchainOperation =
-          memo && (memo.startsWith('=') || memo.startsWith('SWAP') || memo.includes(':'));
-        
+        // Use the top-level isThorchainSwap check
         let gasLimit;
-        if (isThorchainOperation) {
-          // THORChain depositWithExpiry requires more gas (90-120k typical)
-          // Use 120000 to be safe for all network conditions
-          gasLimit = BigInt(120000);
+        if (isThorchainSwap) {
+          // THORChain depositWithExpiry requires more gas (90-100k typical)
+          // Use 100000 with 10% buffer for safety (reduced from 120000 to minimize gas fees)
+          gasLimit = BigInt(100000);
           console.log(tag, 'Using higher gas limit for THORChain swap:', gasLimit.toString());
         } else {
           // Standard gas limit for ETH transfer
@@ -300,7 +310,7 @@ export async function createUnsignedEvmTx(
           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; // Approximate additional gas
           //console.log(tag, 'Adjusted gasLimit for memo:', gasLimit.toString());
@@ -321,17 +331,37 @@ export async function createUnsignedEvmTx(
           console.log(tag, 'isMax calculation - balance:', balance.toString(), 'gasFee:', gasFee.toString(), 'buffer:', buffer.toString(), 'amountWei:', amountWei.toString());
         } else {
           amountWei = BigInt(Math.round(amount * 1e18));
-          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 balanceEth = (Number(balance) / 1e18).toFixed(6);
+            const amountEth = (Number(amountWei) / 1e18).toFixed(6);
+            const gasFeeEth = (Number(gasFee) / 1e18).toFixed(6);
+            const availableEth = (Number(availableForSwap) / 1e18).toFixed(6);
+            const swapType = isThorchainSwap ? 'THORChain swap' : 'transfer';
+
+            throw new Error(
+              `Insufficient funds for the transaction amount and gas fees.\n` +
+              `Balance: ${balanceEth} ETH\n` +
+              `Attempting to ${swapType}: ${amountEth} ETH\n` +
+              `Estimated gas fee: ${gasFeeEth} ETH (${gasLimit.toString()} gas limit)\n` +
+              `Total needed: ${(Number(totalNeeded) / 1e18).toFixed(6)} ETH\n` +
+              `Maximum swappable: ${availableEth} ETH (after gas fees)`
+            );
           }
         }
 
-        //console.log(tag, 'amountWei:', amountWei.toString());
-
-        // Check if this is a THORChain swap (memo starts with '=' or 'SWAP' or contains ':')
-        const isThorchainSwap =
-          memo && (memo.startsWith('=') || memo.startsWith('SWAP') || memo.includes(':'));
+        console.log(tag, 'Transaction calculation:', {
+          balance: balance.toString() + ' wei (' + (Number(balance) / 1e18).toFixed(6) + ' ETH)',
+          amountWei: amountWei.toString() + ' wei (' + (Number(amountWei) / 1e18).toFixed(6) + ' ETH)',
+          gasFee: gasFee.toString() + ' wei (' + (Number(gasFee) / 1e18).toFixed(6) + ' ETH)',
+          gasLimit: gasLimit.toString(),
+          gasPrice: gasPrice.toString() + ' wei (' + (Number(gasPrice) / 1e9).toFixed(2) + ' gwei)',
+          isThorchainSwap: isThorchainSwap,
+        });
 
+        // Use the top-level isThorchainSwap check (defined before switch statement)
         let txData = '0x';
 
         if (isThorchainSwap) {
@@ -366,19 +396,35 @@ export async function createUnsignedEvmTx(
               const inboundResponse = await fetch('https://thornode.ninerealms.com/thorchain/inbound_addresses');
               if (inboundResponse.ok) {
                 const inboundData = await inboundResponse.json();
-                // Find ETH inbound data
-                const ethInbound = inboundData.find(inbound => 
-                  inbound.chain === 'ETH' && !inbound.halted
+
+                // Map chainId to THORChain chain name
+                const chainIdToThorchain: Record<number, string> = {
+                  1: 'ETH',      // Ethereum mainnet
+                  43114: 'AVAX', // Avalanche
+                  8453: 'BASE',  // Base
+                  56: 'BSC',     // Binance Smart Chain
+                };
+
+                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);
+
+                // Find inbound data for the specific chain
+                const chainInbound = inboundData.find(inbound =>
+                  inbound.chain === thorchainName && !inbound.halted
                 );
-                if (ethInbound) {
-                  vaultAddress = ethInbound.address; // This is the Asgard vault
-                  routerAddress = ethInbound.router || to; // Use fetched router or fallback to 'to'
+                if (chainInbound) {
+                  vaultAddress = chainInbound.address; // This is the Asgard vault
+                  routerAddress = chainInbound.router || to; // Use fetched router or fallback to 'to'
                   console.log(tag, 'Using THORChain inbound addresses - vault:', vaultAddress, 'router:', routerAddress);
-                  
+
                   // Update the 'to' address to be the router (in case it wasn't)
                   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) {
@@ -392,6 +438,21 @@ export async function createUnsignedEvmTx(
               throw new Error('Cannot proceed with THORChain swap - vault address is invalid (0x0)');
             }
 
+            // CRITICAL SAFETY CHECK: Ensure we're sending to the router, not the vault
+            // This prevents the original bug where USDC was sent to a user wallet
+            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; // Override with correct router
+            }
+
+            // Validate router address format
+            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);
+
             // Use depositWithExpiry for better safety
             // Function signature: depositWithExpiry(address,address,uint256,string,uint256)
             // Function selector: 0x44bc937b
@@ -539,10 +600,143 @@ export async function createUnsignedEvmTx(
         // For simplicity, we assume user has enough tokens
         // In practice, need to check token balance
 
-        const data = encodeTransferData(to, amountWei);
+        let data: string;
+        let finalTo: string;
+
+        // Check if this is a THORChain swap
+        if (isThorchainSwap) {
+          console.log(tag, '🔄 ERC20 THORChain swap detected - encoding depositWithExpiry');
+
+          // For ERC20 THORChain swaps, we need to:
+          // 1. Approve the router to spend tokens (done separately by user)
+          // 2. Call router.depositWithExpiry(vault, asset, amount, memo, expiry)
+
+          // Fetch router and vault addresses from THORChain (same as native ETH flow)
+          let vaultAddress = '0x0000000000000000000000000000000000000000';
+          let routerAddress = to; // The 'to' field should already be the router
+
+          try {
+            // Fetch inbound addresses from THORChain
+            const inboundResponse = await fetch('https://thornode.ninerealms.com/thorchain/inbound_addresses');
+            if (inboundResponse.ok) {
+              const inboundData = await inboundResponse.json();
+
+              // Map chainId to THORChain chain name
+              const chainIdToThorchain: Record<number, string> = {
+                1: 'ETH',      // Ethereum mainnet
+                43114: 'AVAX', // Avalanche
+                8453: 'BASE',  // Base
+                56: 'BSC',     // Binance Smart Chain
+              };
+
+              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);
+
+              // Find inbound data for the specific chain
+              const chainInbound = inboundData.find(inbound =>
+                inbound.chain === thorchainName && !inbound.halted
+              );
+              if (chainInbound) {
+                vaultAddress = chainInbound.address; // This is the Asgard vault
+                routerAddress = chainInbound.router || to; // Use fetched router or fallback to 'to'
+                console.log(tag, 'Using THORChain inbound addresses - vault:', vaultAddress, 'router:', routerAddress);
+
+                // Update the 'to' address to be the router (in case it wasn't)
+                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);
+            // ABORT - cannot proceed without proper vault address
+            throw new Error(`Cannot proceed with THORChain swap - failed to fetch inbound addresses: ${fetchError.message}`);
+          }
+
+          // Final validation - never use 0x0 as vault
+          if (vaultAddress === '0x0000000000000000000000000000000000000000') {
+            throw new Error('Cannot proceed with THORChain swap - vault address is invalid (0x0)');
+          }
+
+          // CRITICAL SAFETY CHECK: Ensure we're sending to the router, not the vault
+          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; // Override with correct router
+          }
+
+          // Validate router address format
+          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);
+
+          // Encode depositWithExpiry for ERC20 tokens
+          // Function signature: depositWithExpiry(address,address,uint256,string,uint256)
+          const functionSelector = '44bc937b';
+
+          // Calculate expiry time (current time + 1 hour)
+          const expiryTime = Math.floor(Date.now() / 1000) + 3600;
+
+          // Encode parameters
+          const vaultPadded = vaultAddress.toLowerCase().replace(/^0x/, '').padStart(64, '0');
+          const assetPadded = contractAddress.toLowerCase().replace(/^0x/, '').padStart(64, '0'); // ERC20 token address
+          const amountPadded = amountWei.toString(16).padStart(64, '0');
+
+          // String offset for depositWithExpiry with 5 parameters
+          // Offset must point after all 5 head words: 5 * 32 = 160 = 0xa0
+          const stringOffset = (5 * 32).toString(16).padStart(64, '0');
+
+          const expiryPadded = expiryTime.toString(16).padStart(64, '0');
+
+          // Encode memo
+          const fixedMemo = memo || '';
+          const memoBytes = Buffer.from(fixedMemo, 'utf8');
+          const memoHex = memoBytes.toString('hex');
+          const stringLength = memoBytes.length.toString(16).padStart(64, '0');
+
+          // Pad memo to 32-byte boundary
+          const paddingLength = (32 - (memoBytes.length % 32)) % 32;
+          const memoPadded = memoHex + '0'.repeat(paddingLength * 2);
+
+          // Construct transaction data
+          data = '0x' + functionSelector + vaultPadded + assetPadded + amountPadded + stringOffset + expiryPadded + stringLength + memoPadded;
+
+          // Set recipient to router (NOT token contract)
+          finalTo = to; // 'to' has been validated and updated to be the router
+
+          console.log(tag, '✅ Encoded ERC20 depositWithExpiry:', {
+            functionSelector: '0x' + functionSelector,
+            vault: vaultAddress,
+            asset: contractAddress,
+            amount: amountWei.toString(),
+            memo: fixedMemo,
+            expiry: expiryTime,
+            dataLength: data.length,
+          });
+
+          // Increase gas limit for router call (more complex than simple transfer)
+          // ERC20 depositWithExpiry typically uses 150-200k gas
+          gasLimit = BigInt(200000); // Reduced from 300k - router calls with 33% buffer
+        } else {
+          // Regular ERC20 transfer (non-THORChain)
+          data = encodeTransferData(to, amountWei);
+          finalTo = contractAddress;
+        }
 
         const ethPriceInUsd = await fetchEthPriceInUsd(pioneer, networkId);
-        const gasFeeUsd = (Number(gasFee) / 1e18) * ethPriceInUsd;
+        // Recalculate gasFee in case gasLimit was updated for THORChain swap
+        const finalGasFee = gasPrice * gasLimit;
+        const gasFeeUsd = (Number(finalGasFee) / 1e18) * ethPriceInUsd;
 
         // For token price, fetch from Pioneer API using the full CAIP
         const tokenPriceInUsd = await fetchTokenPriceInUsd(pioneer, caip);
@@ -551,10 +745,11 @@ export async function createUnsignedEvmTx(
 
         unsignedTx = {
           chainId,
+          from: address,  // Required for simulation
           nonce: toHex(nonce),
           gas: toHex(gasLimit),
           gasPrice: toHex(gasPrice),
-          to: contractAddress,
+          to: finalTo,
           value: '0x0',
           data,
           // USD estimations