@pioneer-platform/pioneer-sdk 0.0.81 → 4.13.30

package/src/txbuilder/templates/osmosis.ts

@@ -0,0 +1,30 @@
+export const osmosisTransferTemplate = (params: {
+  account_number: string;
+  chain_id: string;
+  fee: { gas: string; amount: any[] };
+  from_address: string;
+  to_address: string;
+  asset: string;
+  amount: string;
+  memo: string;
+  sequence: string;
+}) => ({
+  signerAddress: params.from_address,
+  signDoc: {
+    account_number: params.account_number,
+    chain_id: params.chain_id,
+    fee: params.fee,
+    msgs: [
+      {
+        value: {
+          amount: [{ denom: params.asset, amount: params.amount }],
+          to_address: params.to_address,
+          from_address: params.from_address,
+        },
+        type: 'cosmos-sdk/MsgSend',
+      },
+    ],
+    memo: params.memo,
+    sequence: params.sequence,
+  },
+});

package/src/txbuilder/templates/thorchain.ts

@@ -0,0 +1,60 @@
+export const thorchainTransferTemplate = (params: {
+  account_number: string;
+  chain_id: string;
+  fee: { gas: string; amount: any[] };
+  from_address: string;
+  to_address: string;
+  asset: string;
+  amount: string;
+  memo: string;
+  sequence: string;
+}) => ({
+  signerAddress: params.from_address,
+  signDoc: {
+    account_number: params.account_number,
+    chain_id: params.chain_id,
+    fee: params.fee,
+    msgs: [
+      {
+        value: {
+          amount: [{ denom: params.asset, amount: params.amount }],
+          to_address: params.to_address,
+          from_address: params.from_address,
+        },
+        type: 'cosmos-sdk/MsgSend' as const,
+      },
+    ],
+    memo: params.memo,
+    sequence: params.sequence,
+  },
+});
+
+export const thorchainDepositTemplate = (params: {
+  account_number: string;
+  chain_id: string;
+  fee: { gas: string; amount: any[] };
+  from_address: string;
+  asset: string;
+  amount: string;
+  memo: string;
+  sequence: string;
+}) => ({
+  signerAddress: params.from_address,
+  signDoc: {
+    account_number: params.account_number,
+    chain_id: params.chain_id,
+    fee: params.fee,
+    msgs: [
+      {
+        value: {
+          coins: [{ asset: 'THOR.RUNE', amount: params.amount }],
+          memo: params.memo,
+          signer: params.from_address,
+        },
+        type: 'thorchain/MsgDeposit',
+      },
+    ],
+    memo: params.memo,
+    sequence: params.sequence,
+  },
+});

package/src/utils/build-dashboard.ts

@@ -0,0 +1,181 @@
+import { caipToNetworkId, networkIdToCaip } from '@pioneer-platform/pioneer-caip';
+
+const TAG = ' | build-dashboard | ';
+
+// Build dashboard from cached balances (no Pioneer API calls)
+export function buildDashboardFromBalances(balances: any[], blockchains: string[], assetsMap: Map<string, any>) {
+  console.log(TAG, '[DASHBOARD] Building dashboard from cached balances...');
+
+  const dashboardData: {
+    networks: {
+      networkId: string;
+      totalValueUsd: number;
+      gasAssetCaip: string | null;
+      gasAssetSymbol: string | null;
+      icon: string | null;
+      color: string | null;
+      totalNativeBalance: string;
+    }[];
+    totalValueUsd: number;
+    networkPercentages: { networkId: string; percentage: number }[];
+  } = {
+    networks: [],
+    totalValueUsd: 0,
+    networkPercentages: [],
+  };
+
+  let totalPortfolioValue = 0;
+  const networksTemp: {
+    networkId: string;
+    totalValueUsd: number;
+    gasAssetCaip: string | null;
+    gasAssetSymbol: string | null;
+    icon: string | null;
+    color: string | null;
+    totalNativeBalance: string;
+  }[] = [];
+
+  console.log(TAG, 'balances: ', balances);
+
+  // Calculate totals for each blockchain
+  for (const blockchain of blockchains) {
+    const filteredBalances = balances.filter((b) => {
+      const networkId = caipToNetworkId(b.caip);
+      return (
+        networkId === blockchain ||
+        (blockchain === 'eip155:*' && networkId.startsWith('eip155:'))
+      );
+    });
+
+    // Deduplicate balances based on caip + pubkey combination
+    const balanceMap = new Map();
+
+    // Special handling for Bitcoin to work around API bug
+    const isBitcoin = blockchain.includes('bip122:000000000019d6689c085ae165831e93');
+    if (isBitcoin) {
+      console.log(TAG, 'Bitcoin network detected - checking for duplicate balances');
+      // Group Bitcoin balances by value to detect duplicates
+      const bitcoinByValue = new Map();
+      filteredBalances.forEach((balance) => {
+        const valueKey = `${balance.balance}_${balance.valueUsd}`;
+        if (!bitcoinByValue.has(valueKey)) {
+          bitcoinByValue.set(valueKey, []);
+        }
+        bitcoinByValue.get(valueKey).push(balance);
+      });
+
+      // Check if all three address types have the same non-zero balance (API bug)
+      for (const [valueKey, balances] of bitcoinByValue.entries()) {
+        if (balances.length === 3 && parseFloat(balances[0].valueUsd || '0') > 0) {
+          console.log(
+            TAG,
+            'BITCOIN API BUG DETECTED: All 3 address types have same balance, keeping only xpub',
+          );
+          // Keep only the xpub (or first one if no xpub)
+          const xpubBalance = balances.find((b) => b.pubkey?.startsWith('xpub')) || balances[0];
+          const key = `${xpubBalance.caip}_${xpubBalance.pubkey || 'default'}`;
+          balanceMap.set(key, xpubBalance);
+        } else {
+          // Add all balances normally
+          balances.forEach((balance) => {
+            const key = `${balance.caip}_${balance.pubkey || 'default'}`;
+            balanceMap.set(key, balance);
+          });
+        }
+      }
+    } else {
+      // Standard deduplication for non-Bitcoin networks
+      filteredBalances.forEach((balance) => {
+        const key = `${balance.caip}_${balance.pubkey || 'default'}`;
+        // Only keep the first occurrence or the one with higher value
+        if (
+          !balanceMap.has(key) ||
+          parseFloat(balance.valueUsd || '0') > parseFloat(balanceMap.get(key).valueUsd || '0')
+        ) {
+          balanceMap.set(key, balance);
+        }
+      });
+    }
+
+    const networkBalances = Array.from(balanceMap.values());
+
+    // Ensure we're working with numbers for calculations
+    const networkTotal = networkBalances.reduce((sum, balance, idx) => {
+      const valueUsd =
+        typeof balance.valueUsd === 'string'
+          ? parseFloat(balance.valueUsd)
+          : balance.valueUsd || 0;
+
+      if (blockchain.includes('bip122:000000000019d6689c085ae165831e93')) {
+        console.log(
+          TAG,
+          `[BITCOIN DEBUG ${idx}] pubkey:`,
+          balance.pubkey?.substring(0, 10) + '...',
+          '| balance:',
+          balance.balance,
+          '| valueUsd:',
+          balance.valueUsd,
+          '→ parsed:',
+          valueUsd,
+          '| running sum:',
+          sum + valueUsd,
+        );
+      }
+
+      return sum + valueUsd;
+    }, 0);
+
+    // Get native asset for this blockchain
+    const nativeAssetCaip = networkIdToCaip(blockchain);
+    const gasAsset = networkBalances.find((b) => b.caip === nativeAssetCaip);
+
+    // Calculate total native balance (sum of all balances for the native asset)
+    const totalNativeBalance = networkBalances
+      .filter((b) => b.caip === nativeAssetCaip)
+      .reduce((sum, balance) => {
+        const balanceNum =
+          typeof balance.balance === 'string'
+            ? parseFloat(balance.balance)
+            : balance.balance || 0;
+        return sum + balanceNum;
+      }, 0)
+      .toString();
+
+    // Get colors from assetMap since balances don't have them
+    const assetInfo = nativeAssetCaip ? assetsMap.get(nativeAssetCaip) : null;
+
+    networksTemp.push({
+      networkId: blockchain,
+      totalValueUsd: networkTotal,
+      gasAssetCaip: nativeAssetCaip || null,
+      gasAssetSymbol: gasAsset?.ticker || gasAsset?.symbol || assetInfo?.symbol || null,
+      icon: gasAsset?.icon || assetInfo?.icon || null,
+      color: gasAsset?.color || assetInfo?.color || null,
+      totalNativeBalance,
+    });
+
+    totalPortfolioValue += networkTotal;
+  }
+
+  // Sort networks by USD value and assign to dashboard
+  dashboardData.networks = networksTemp.sort((a, b) => b.totalValueUsd - a.totalValueUsd);
+  dashboardData.totalValueUsd = totalPortfolioValue;
+
+  // Calculate network percentages for pie chart
+  dashboardData.networkPercentages = dashboardData.networks
+    .map((network) => ({
+      networkId: network.networkId,
+      percentage:
+        totalPortfolioValue > 0
+          ? Number(((network.totalValueUsd / totalPortfolioValue) * 100).toFixed(2))
+          : 0,
+    }))
+    .filter((entry) => entry.percentage > 0); // Remove zero percentages
+
+  console.log(
+    `[FAST DASHBOARD] ✅ Built dashboard: ${
+      dashboardData.networks.length
+    } networks, $${totalPortfolioValue.toFixed(2)} total`,
+  );
+  return dashboardData;
+}

package/src/utils/format-time.ts

@@ -0,0 +1,12 @@
+// Helper function to format time differences
+export function formatTime(durationMs: number): string {
+  let seconds = Math.floor((durationMs / 1000) % 60);
+  let minutes = Math.floor((durationMs / (1000 * 60)) % 60);
+  let hours = Math.floor((durationMs / (1000 * 60 * 60)) % 24);
+
+  let formatted = '';
+  if (hours > 0) formatted += `${hours}h `;
+  if (minutes > 0 || hours > 0) formatted += `${minutes}m `;
+  formatted += `${seconds}s`;
+  return formatted.trim();
+}

package/src/utils/kkapi-detection.ts

@@ -0,0 +1,64 @@
+// Utility function to detect if kkapi is available with smart environment detection
+export async function detectKkApiAvailability(forceLocalhost?: boolean): Promise<{
+  isAvailable: boolean;
+  baseUrl: string;
+  basePath: string;
+}> {
+  const tag = ' | detectKkApiAvailability | ';
+
+  try {
+    // Smart detection: Check environment (Tauri, browser, or Node.js)
+    const isTauri = typeof window !== 'undefined' && '__TAURI__' in window;
+    const isBrowser = typeof window !== 'undefined';
+    const isNodeJS = typeof process !== 'undefined' && process.versions && process.versions.node;
+    const isLocalhost = isBrowser && window.location.hostname === 'localhost';
+
+    // If in Tauri, use kkapi:// (will be proxied by Tauri)
+    if (isTauri) {
+      return {
+        isAvailable: true,
+        baseUrl: 'kkapi://',
+        basePath: 'kkapi://spec/swagger.json',
+      };
+    }
+
+    // In Node.js test environment or localhost browser, test if localhost:1646 is available
+    // Force localhost if flag is set
+    const shouldTestLocalhost = forceLocalhost || isLocalhost || isNodeJS;
+
+    if (shouldTestLocalhost) {
+      const testEnv = isNodeJS ? 'Node.js test environment' : 'development browser';
+      try {
+        const httpResponse = await fetch('http://localhost:1646/api/v1/health', {
+          method: 'GET',
+          signal: AbortSignal.timeout(1000), // 1 second timeout for localhost
+        });
+
+        if (httpResponse.ok) {
+          return {
+            isAvailable: true,
+            baseUrl: 'http://localhost:1646',
+            basePath: 'http://localhost:1646/spec/swagger.json',
+          };
+        }
+      } catch (httpError: any) {
+        console.error('❌ [KKAPI DETECTION] HTTP localhost:1646 not available:', httpError.message);
+      }
+    }
+
+    // Fallback for production non-Tauri or when vault server is not running
+    console.warn('⚠️ [KKAPI DETECTION] Using fallback config (vault may not be available)');
+    return {
+      isAvailable: false,
+      baseUrl: 'http://localhost:1646',
+      basePath: 'http://localhost:1646/spec/swagger.json',
+    };
+  } catch (error) {
+    console.error('❌ [KKAPI DETECTION] Error during detection:', error);
+    return {
+      isAvailable: false,
+      baseUrl: 'http://localhost:1646',
+      basePath: 'http://localhost:1646/spec/swagger.json',
+    };
+  }
+}

package/src/utils/pubkey-helpers.ts

@@ -0,0 +1,75 @@
+// Helper functions for pubkey management and deduplication
+
+// Helper method to generate unique key for a pubkey
+export function getPubkeyKey(pubkey: any): string {
+  return `${pubkey.pubkey}_${pubkey.pathMaster}`;
+}
+
+// Helper method to deduplicate pubkeys array
+export function deduplicatePubkeys(pubkeys: any[]): any[] {
+  const seen = new Set<string>();
+  const deduped = pubkeys.filter((pubkey) => {
+    const key = getPubkeyKey(pubkey);
+    if (seen.has(key)) {
+      return false;
+    }
+    seen.add(key);
+    return true;
+  });
+  return deduped;
+}
+
+// Helper method to validate a pubkey has required fields
+export function validatePubkey(pubkey: any): boolean {
+  return !!(pubkey.pubkey && pubkey.pathMaster);
+}
+
+// Class for managing pubkey collection with deduplication
+export class PubkeyManager {
+  private pubkeys: any[] = [];
+  private pubkeySet: Set<string> = new Set();
+
+  // Helper method to validate and add a single pubkey
+  addPubkey(pubkey: any): boolean {
+    // Validate pubkey has required fields
+    if (!validatePubkey(pubkey)) {
+      return false;
+    }
+
+    const key = getPubkeyKey(pubkey);
+
+    // Check if already exists
+    if (this.pubkeySet.has(key)) {
+      return false;
+    }
+
+    // Add to both array and set
+    this.pubkeys.push(pubkey);
+    this.pubkeySet.add(key);
+    return true;
+  }
+
+  // Helper method to set pubkeys array with deduplication
+  setPubkeys(newPubkeys: any[]): void {
+    // Clear existing
+    this.pubkeys = [];
+    this.pubkeySet.clear();
+
+    // Add each pubkey with validation
+    let added = 0;
+    for (const pubkey of newPubkeys) {
+      if (this.addPubkey(pubkey)) {
+        added++;
+      }
+    }
+  }
+
+  getPubkeys(): any[] {
+    return this.pubkeys;
+  }
+
+  clear(): void {
+    this.pubkeys = [];
+    this.pubkeySet.clear();
+  }
+}

package/lib/index.d.ts

@@ -1,66 +0,0 @@
-export interface SendToAddress {
-    blockchain: string;
-    asset: string;
-    amount: number;
-    address: string;
-    memo?: string;
-    noBroadcast?: boolean;
-}
-export interface config {
-    spec: string;
-    env: string;
-    mode: string;
-    username: string;
-    addresses?: [];
-    wallet?: any;
-    pubkeys?: any;
-    auth?: string;
-    paths?: any;
-    privWallet?: any;
-    mnemonic?: string;
-    queryKey?: string;
-    offline?: boolean;
-    pioneerApi?: boolean;
-}
-export interface Invocation {
-    coin: string;
-    addressFrom?: string;
-    addressTo: string;
-    amount: string;
-    memo: string;
-    nonce?: number;
-}
-export declare class SDK {
-    private spec;
-    private pioneerApi;
-    private init;
-    private config;
-    private clients;
-    private createPairingCode;
-    private queryKey;
-    private service;
-    private isTestnet;
-    private getUserParams;
-    private sendToAddress;
-    private url;
-    private events;
-    private wss;
-    private username;
-    private blockchains;
-    private startSocket;
-    private isPaired;
-    private context;
-    private info;
-    private wallets;
-    private totalValueUsd;
-    private getUserInfo;
-    private getWalletInfo;
-    private setContext;
-    private getInvocations;
-    private invocationContext;
-    private assetContext;
-    private assetBalanceUsdValueContext;
-    private assetBalanceNativeContext;
-    private getInvocation;
-    constructor(spec: string, config: any, isTestnet?: boolean);
-}