@pioneer-platform/pioneer-sdk 8.11.28 → 8.12.2

package/dist/index.cjs

@@ -1074,17 +1074,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) {
+        if (isThorchainSwap) {
           gasLimit = BigInt(120000);
           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;
         }
@@ -1103,7 +1103,6 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
             throw new Error("Insufficient funds for the transaction amount and gas fees");
           }
         }
-        const isThorchainSwap = memo && (memo.startsWith("=") || memo.startsWith("SWAP") || memo.includes(":"));
         let txData = "0x";
         if (isThorchainSwap) {
           console.log(tag, "Detected THORChain swap, encoding deposit data for memo:", memo);
@@ -1125,14 +1124,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) {
@@ -1142,6 +1152,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;
@@ -1230,17 +1249,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(300000);
+        } 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,
@@ -4100,8 +4200,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!");

package/dist/index.es.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) {
+        if (isThorchainSwap) {
           gasLimit = BigInt(120000);
           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;
         }
@@ -1279,7 +1279,6 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
             throw new Error("Insufficient funds for the transaction amount and gas fees");
           }
         }
-        const isThorchainSwap = memo && (memo.startsWith("=") || memo.startsWith("SWAP") || memo.includes(":"));
         let txData = "0x";
         if (isThorchainSwap) {
           console.log(tag, "Detected THORChain swap, encoding deposit data for memo:", memo);
@@ -1301,14 +1300,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 +1328,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 +1425,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(300000);
+        } 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 +4376,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!");

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) {
+        if (isThorchainSwap) {
           gasLimit = BigInt(120000);
           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;
         }
@@ -1279,7 +1279,6 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
             throw new Error("Insufficient funds for the transaction amount and gas fees");
           }
         }
-        const isThorchainSwap = memo && (memo.startsWith("=") || memo.startsWith("SWAP") || memo.includes(":"));
         let txData = "0x";
         if (isThorchainSwap) {
           console.log(tag, "Detected THORChain swap, encoding deposit data for memo:", memo);
@@ -1301,14 +1300,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 +1328,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 +1425,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(300000);
+        } 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 +4376,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!");

package/package.json

@@ -1,15 +1,15 @@
 {
   "author": "highlander",
   "name": "@pioneer-platform/pioneer-sdk",
-  "version": "8.11.28",
+  "version": "8.12.2",
   "dependencies": {
     "@keepkey/keepkey-sdk": "^0.2.62",
     "@pioneer-platform/loggerdog": "^8.11.0",
     "@pioneer-platform/pioneer-caip": "^9.10.0",
     "@pioneer-platform/pioneer-client": "^9.10.10",
     "@pioneer-platform/pioneer-coins": "^9.11.0",
-    "@pioneer-platform/pioneer-discovery": "^8.11.28",
-    "@pioneer-platform/pioneer-events": "^8.11.0",
+    "@pioneer-platform/pioneer-discovery": "^8.12.0",
+    "@pioneer-platform/pioneer-events": "^8.12.0",
     "coinselect": "^3.1.13",
     "eventemitter3": "^5.0.1",
     "neotraverse": "^0.6.8",

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!');

package/src/txbuilder/createUnsignedEvmTx.ts

@@ -281,15 +281,17 @@ 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) {
+        if (isThorchainSwap) {
           // THORChain depositWithExpiry requires more gas (90-120k typical)
           // Use 120000 to be safe for all network conditions
           gasLimit = BigInt(120000);
@@ -300,7 +302,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());
@@ -328,10 +330,7 @@ export async function createUnsignedEvmTx(
 
         //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(':'));
-
+        // Use the top-level isThorchainSwap check (defined before switch statement)
         let txData = '0x';
 
         if (isThorchainSwap) {
@@ -366,19 +365,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 +407,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 +569,142 @@ 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)
+          gasLimit = BigInt(300000); // Router calls require more gas than simple transfers
+        } 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 +713,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