@pioneer-platform/pioneer-sdk 4.21.0 → 4.21.2

package/package.json

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

package/src/charts/custom-tokens.ts

@@ -0,0 +1,144 @@
+/**
+ * Custom Tokens Chart Module
+ *
+ * Fetches user-defined custom token balances from MongoDB-backed server endpoint
+ * Follows the stablecoin chart pattern for network-specific token discovery
+ */
+
+import { ChartBalance, ChartParams, PortfolioToken } from './types';
+import { hydrateAssetData, checkDuplicateBalance, createBalanceIdentifier } from './utils';
+
+const tag = '| charts-custom-tokens |';
+
+/**
+ * Fetch custom tokens for a user address across all EVM networks
+ *
+ * This function queries the server for user-defined custom tokens and fetches their balances.
+ * Custom tokens are stored in MongoDB per user address with network-specific configuration.
+ *
+ * @param params Chart parameters including pioneer client, pubkeys, and blockchains
+ * @param balances Existing balances array (to check for duplicates)
+ * @returns Promise that resolves when custom tokens are added to balances array
+ */
+export async function fetchCustomTokens(
+  params: ChartParams,
+  balances: ChartBalance[]
+): Promise<void> {
+  const { pioneer, pubkeys, blockchains, context } = params;
+
+  console.log(tag, 'Fetching custom tokens...');
+
+  // Find the primary EVM address
+  const evmPubkey = pubkeys.find(
+    (e: any) => e.networks && Array.isArray(e.networks) && e.networks.includes('eip155:*')
+  );
+  const primaryAddress = evmPubkey?.address || evmPubkey?.master;
+
+  if (!primaryAddress) {
+    console.log(tag, 'No EVM address found, skipping custom tokens');
+    return;
+  }
+
+  console.log(tag, 'Using EVM address for custom tokens:', primaryAddress);
+
+  // Networks that support custom tokens endpoint (all EVM networks)
+  const supportedNetworks = blockchains.filter((net: string) => net.startsWith('eip155:'));
+
+  if (supportedNetworks.length === 0) {
+    console.log(tag, 'No EVM networks for custom tokens');
+    return;
+  }
+
+  console.log(tag, `Checking custom tokens on ${supportedNetworks.length} networks`);
+
+  // Fetch custom tokens for each network
+  for (const networkId of supportedNetworks) {
+    try {
+      const response = await pioneer.GetCustomTokens({ networkId, address: primaryAddress });
+      const customTokens = response?.data?.tokens || [];
+
+      console.log(tag, `Found ${customTokens.length} custom tokens on ${networkId}`);
+
+      // Process each custom token
+      for (const token of customTokens) {
+        // Convert to ChartBalance format
+        const chartBalance = processCustomToken(token, primaryAddress, context, blockchains);
+
+        // Add if not already in balances (avoid duplicates)
+        if (chartBalance && !checkDuplicateBalance(balances, chartBalance.caip, chartBalance.pubkey)) {
+          balances.push(chartBalance);
+          console.log(tag, `Added custom token: ${chartBalance.symbol} = ${chartBalance.balance}`);
+        }
+      }
+    } catch (error: any) {
+      console.error(tag, `Error fetching custom tokens for ${networkId}:`, error.message);
+      // Continue with other networks even if one fails
+    }
+  }
+
+  console.log(tag, `Custom tokens complete. Total balances: ${balances.length}`);
+}
+
+/**
+ * Process a custom token into ChartBalance format
+ * Follows the same pattern as processPortfolioToken in evm.ts
+ */
+function processCustomToken(
+  token: PortfolioToken,
+  primaryAddress: string,
+  context: string,
+  blockchains: string[]
+): ChartBalance | null {
+  if (!token.assetCaip || !token.networkId) {
+    return null;
+  }
+
+  // Extract the networkId from the assetCaip
+  let extractedNetworkId = token.networkId;
+
+  // For tokens with special formats, extract network part
+  if (token.assetCaip.includes('/denom:')) {
+    const parts = token.assetCaip.split('/denom:');
+    if (parts.length > 0) {
+      extractedNetworkId = parts[0];
+    }
+  } else if (token.networkId && token.networkId.includes('/')) {
+    extractedNetworkId = token.networkId.split('/')[0];
+  }
+
+  // Accept ALL EIP155 chains (since we have eip155:* pubkey)
+  const isEip155 = extractedNetworkId.startsWith('eip155:');
+  if (!isEip155 && !blockchains.includes(extractedNetworkId)) {
+    return null;
+  }
+
+  // Hydrate token with assetData
+  const tokenAssetInfo = hydrateAssetData(token.assetCaip);
+
+  // Use consistent pubkey
+  const tokenPubkey = token.pubkey || primaryAddress;
+
+  const chartBalance: ChartBalance = {
+    context,
+    chart: 'pioneer',
+    contextType: context.split(':')[0],
+    name: tokenAssetInfo?.name || token.token?.name || 'Unknown Custom Token',
+    caip: token.assetCaip,
+    icon: tokenAssetInfo?.icon || token.token?.icon || '',
+    pubkey: tokenPubkey,
+    ticker: tokenAssetInfo?.symbol || token.token?.symbol || 'UNK',
+    ref: `${context}${token.assetCaip}`,
+    identifier: createBalanceIdentifier(token.assetCaip, tokenPubkey),
+    networkId: extractedNetworkId,
+    symbol: tokenAssetInfo?.symbol || token.token?.symbol || 'UNK',
+    type: tokenAssetInfo?.type || 'erc20',
+    token: true, // Custom tokens are always tokens
+    decimal: tokenAssetInfo?.decimal || token.token?.decimal,
+    balance: token.token?.balance?.toString() || '0',
+    priceUsd: token.token?.price || 0,
+    valueUsd: token.token?.balanceUSD || 0,
+    updated: new Date().getTime(),
+  };
+
+  return chartBalance;
+}

package/src/charts/evm.ts

@@ -1,5 +1,6 @@
 import { ChartBalance, ChartParams, PortfolioBalance, PortfolioToken } from './types';
 import { hydrateAssetData, checkDuplicateBalance, createBalanceIdentifier } from './utils';
+import { fetchCustomTokens } from './custom-tokens';
 
 const tag = '| charts-evm |';
 
@@ -32,6 +33,10 @@ export async function getEvmCharts(params: ChartParams): Promise<ChartBalance[]>
   // This ensures USDC/USDT balances are always available even if Zapper fails
   await fetchStableCoins(pioneer, primaryAddress, blockchains, balances, context);
 
+  // CUSTOM TOKENS: Fetch user-defined custom tokens from MongoDB-backed endpoint
+  // This ensures user's custom tokens are always included in their portfolio
+  await fetchCustomTokens({ blockchains, pioneer, pubkeys, context }, balances);
+
   try {
     // NOTE: Zapper API returns portfolio data across ALL networks for a given address
     // We use eip155:1 as the networkId parameter, but Zapper will return data for all EVM chains

package/src/index.ts

@@ -952,7 +952,7 @@ export class SDK {
         throw e;
       }
     };
-    this.signTx = async function (unsignedTx: any) {
+    this.signTx = async function (caip: string, unsignedTx: any) {
       let tag = TAG + ' | signTx | ';
       try {
         const transactionDependencies = {
@@ -966,7 +966,7 @@ export class SDK {
           keepKeySdk: this.keepKeySdk,
         };
         let txManager = new TransactionManager(transactionDependencies, this.events);
-        let signedTx = await txManager.sign(unsignedTx);
+        let signedTx = await txManager.sign({ caip, unsignedTx });
         return signedTx;
       } catch (e) {
         console.error(e);
@@ -1119,13 +1119,12 @@ export class SDK {
         }
 
         let quote = {
-          affiliate: '0x658DE0443259a1027caA976ef9a42E6982037A03',
-          sellAsset: this.assetContext,
+          sellAsset: this.assetContext.caip,  // Send CAIP string, not object
           sellAmount: inputAmount.toPrecision(8),
-          buyAsset: this.outboundAssetContext,
+          buyAsset: this.outboundAssetContext.caip,  // Send CAIP string, not object
           recipientAddress, // Fill this based on your logic
           senderAddress, // Fill this based on your logic
-          slippage: '3',
+          slippage: swapPayload.slippagePercentage || 3,
         };
 
         let result: any;
@@ -1134,10 +1133,13 @@ export class SDK {
           result = result.data;
         } catch (e) {
           console.error(tag, 'Failed to get quote: ', e);
+          throw Error(
+            'Quote API failed for path: ' + quote.sellAsset + ' -> ' + quote.buyAsset + '. Error: ' + e,
+          );
         }
-        if (result.length === 0)
+        if (!result || result.length === 0)
           throw Error(
-            'No quotes available! path: ' + quote.sellAsset.caip + ' -> ' + quote.buyAsset.caip,
+            'No quotes available! path: ' + quote.sellAsset + ' -> ' + quote.buyAsset,
           );
         //TODO let user handle selecting quote?
         let selected = result[0];
@@ -1145,12 +1147,14 @@ export class SDK {
         if (!txs) throw Error('invalid quote!');
         for (let i = 0; i < txs.length; i++) {
           let tx = txs[i];
+
           const transactionDependencies = {
             context: this.context,
             assetContext: this.assetContext,
             balances: this.balances,
             pioneer: this.pioneer,
             pubkeys: this.pubkeys,
+            pubkeyContext: this.pubkeyContext,
             nodes: this.nodes,
             keepKeySdk: this.keepKeySdk,
           };
@@ -1161,7 +1165,7 @@ export class SDK {
 
           let unsignedTx;
           if (tx.type === 'deposit') {
-            //build deposit tx
+            //build deposit tx (Tendermint chains)
             unsignedTx = await createUnsignedTendermintTx(
               caip,
               tx.type,
@@ -1169,11 +1173,16 @@ export class SDK {
               tx.txParams.memo,
               this.pubkeys,
               this.pioneer,
-              this.keepKeySdk,
+              this.pubkeyContext,
               false,
               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;
           } else {
+            //transfer transaction (UTXO chains) - requires memo
             if (!tx.txParams.memo) throw Error('memo required on swaps!');
             const sendPayload: any = {
               caip,

package/src/txbuilder/createUnsignedEvmTx.ts

@@ -269,9 +269,10 @@ export async function createUnsignedEvmTx(
     //console.log(tag, 'nonce:', nonce);
 
     const balanceData = await pioneer.GetBalanceAddressByNetwork({ networkId, address });
-    const balanceEth = parseFloat(balanceData.data.balance); // Assuming this is in ETH
+    // Use nativeBalance for ETH balance (needed for gas fees), fallback to balance
+    const balanceEth = parseFloat(balanceData.data.nativeBalance || balanceData.data.balance || '0'); // Native ETH balance
     const balance = BigInt(Math.round(balanceEth * 1e18)); // Convert to wei
-    //console.log(tag, 'balance (wei):', balance.toString());
+    console.log(tag, 'Native ETH balance from API:', balanceData.data.nativeBalance || balanceData.data.balance, 'ETH (', balance.toString(), 'wei)');
     if (balance <= 0n) throw new Error('Wallet balance is zero');
 
     // Classify asset type by CAIP
@@ -529,8 +530,12 @@ export async function createUnsignedEvmTx(
           });
         }
 
-        // Ensure user has enough ETH to pay for gas
-        if (gasFee > balance) {
+        // Check balance using minimal gas estimate (25k)
+        // We use higher gasLimit (100k) for safety, but check with lower estimate to allow users to "push it"
+        // Most ERC20 transfers use 50-65k gas, so 25k gives users maximum flexibility
+        const estimatedGasForCheck = BigInt(25000);
+        const estimatedGasFee = gasPrice * estimatedGasForCheck;
+        if (estimatedGasFee > balance) {
           throw new Error('Insufficient ETH balance to cover gas fees');
         }
 

package/src/utils/build-dashboard.ts

@@ -12,6 +12,7 @@ export function buildDashboardFromBalances(balances: any[], blockchains: string[
       totalValueUsd: number;
       gasAssetCaip: string | null;
       gasAssetSymbol: string | null;
+      gasAssetName: string | null;
       icon: string | null;
       color: string | null;
       totalNativeBalance: string;
@@ -30,6 +31,7 @@ export function buildDashboardFromBalances(balances: any[], blockchains: string[
     totalValueUsd: number;
     gasAssetCaip: string | null;
     gasAssetSymbol: string | null;
+    gasAssetName: string | null;
     icon: string | null;
     color: string | null;
     totalNativeBalance: string;
@@ -144,11 +146,19 @@ export function buildDashboardFromBalances(balances: any[], blockchains: string[
     // Get colors from assetMap since balances don't have them
     const assetInfo = nativeAssetCaip ? assetsMap.get(nativeAssetCaip) : null;
 
+    // Debug logging
+    console.log(TAG, `[DEBUG] Network: ${blockchain}`);
+    console.log(TAG, `[DEBUG] nativeAssetCaip: ${nativeAssetCaip}`);
+    console.log(TAG, `[DEBUG] assetInfo:`, assetInfo);
+    console.log(TAG, `[DEBUG] gasAsset:`, gasAsset);
+    console.log(TAG, `[DEBUG] Resolved name: ${gasAsset?.name || assetInfo?.name || 'NO NAME'}`);
+
     networksTemp.push({
       networkId: blockchain,
       totalValueUsd: networkTotal,
       gasAssetCaip: nativeAssetCaip || null,
       gasAssetSymbol: gasAsset?.ticker || gasAsset?.symbol || assetInfo?.symbol || null,
+      gasAssetName: gasAsset?.name || assetInfo?.name || null,
       icon: gasAsset?.icon || assetInfo?.icon || null,
       color: gasAsset?.color || assetInfo?.color || null,
       totalNativeBalance,