@pioneer-platform/pioneer-sdk 8.12.2 → 8.12.4

package/dist/index.cjs

@@ -1079,7 +1079,7 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
       case "gas": {
         let gasLimit;
         if (isThorchainSwap) {
-          gasLimit = BigInt(120000);
+          gasLimit = BigInt(1e5);
           console.log(tag, "Using higher gas limit for THORChain swap:", gasLimit.toString());
         } else {
           gasLimit = chainId === 1 ? BigInt(21000) : BigInt(25000);
@@ -1099,10 +1099,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)`);
           }
         }
+        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);
@@ -1324,7 +1344,7 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
             expiry: expiryTime,
             dataLength: data.length
           });
-          gasLimit = BigInt(300000);
+          gasLimit = BigInt(200000);
         } else {
           data = encodeTransferData(to, amountWei);
           finalTo = contractAddress;
@@ -5121,5 +5141,29 @@ 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;

package/dist/index.es.js

@@ -1255,7 +1255,7 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
       case "gas": {
         let gasLimit;
         if (isThorchainSwap) {
-          gasLimit = BigInt(120000);
+          gasLimit = BigInt(1e5);
           console.log(tag, "Using higher gas limit for THORChain swap:", gasLimit.toString());
         } else {
           gasLimit = chainId === 1 ? BigInt(21000) : BigInt(25000);
@@ -1275,10 +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)`);
           }
         }
+        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);
@@ -1500,7 +1520,7 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
             expiry: expiryTime,
             dataLength: data.length
           });
-          gasLimit = BigInt(300000);
+          gasLimit = BigInt(200000);
         } else {
           data = encodeTransferData(to, amountWei);
           finalTo = contractAddress;
@@ -5297,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/dist/index.js

@@ -1255,7 +1255,7 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
       case "gas": {
         let gasLimit;
         if (isThorchainSwap) {
-          gasLimit = BigInt(120000);
+          gasLimit = BigInt(1e5);
           console.log(tag, "Using higher gas limit for THORChain swap:", gasLimit.toString());
         } else {
           gasLimit = chainId === 1 ? BigInt(21000) : BigInt(25000);
@@ -1275,10 +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)`);
           }
         }
+        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);
@@ -1500,7 +1520,7 @@ async function createUnsignedEvmTx(caip, to, amount, memo, pubkeys, pioneer, pub
             expiry: expiryTime,
             dataLength: data.length
           });
-          gasLimit = BigInt(300000);
+          gasLimit = BigInt(200000);
         } else {
           data = encodeTransferData(to, amountWei);
           finalTo = contractAddress;
@@ -5297,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.2",
+  "version": "8.12.4",
   "dependencies": {
     "@keepkey/keepkey-sdk": "^0.2.62",
     "@pioneer-platform/loggerdog": "^8.11.0",

package/src/index.ts

@@ -2624,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

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 | ';
 
@@ -292,9 +300,9 @@ export async function createUnsignedEvmTx(
         // Use the top-level isThorchainSwap check
         let gasLimit;
         if (isThorchainSwap) {
-          // THORChain depositWithExpiry requires more gas (90-120k typical)
-          // Use 120000 to be safe for all network conditions
-          gasLimit = BigInt(120000);
+          // 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
@@ -323,12 +331,35 @@ 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());
+        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';
@@ -694,7 +725,8 @@ export async function createUnsignedEvmTx(
           });
 
           // Increase gas limit for router call (more complex than simple transfer)
-          gasLimit = BigInt(300000); // Router calls require more gas than simple transfers
+          // 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);