@pioneer-platform/pioneer-sdk 0.0.82 → 4.13.30

package/src/charts/evm.ts

@@ -0,0 +1,199 @@
+import { ChartBalance, ChartParams, PortfolioBalance, PortfolioToken } from './types';
+import { hydrateAssetData, checkDuplicateBalance, createBalanceIdentifier } from './utils';
+
+const tag = '| charts-evm |';
+
+export async function getEvmCharts(params: ChartParams): Promise<ChartBalance[]> {
+  const { blockchains, pioneer, pubkeys, context } = params;
+  const balances: ChartBalance[] = [];
+  
+  // Find the primary address for portfolio lookup
+  // ONLY use EVM addresses since the portfolio endpoint uses Zapper which only supports Ethereum
+  const evmPubkey = pubkeys.find(
+    (e: any) => e.networks && Array.isArray(e.networks) && e.networks.includes('eip155:*'),
+  );
+  const primaryAddress = evmPubkey?.address || evmPubkey?.master;
+
+  console.log(tag, 'Total pubkeys available:', pubkeys.length);
+  console.log(tag, 'Blockchains to process:', blockchains);
+
+  // Only call portfolio endpoint if we have an EVM address (Zapper requirement)
+  if (!primaryAddress) {
+    console.log(
+      tag,
+      'No EVM address found, skipping portfolio lookup (Zapper only supports Ethereum)',
+    );
+    return balances;
+  }
+
+  console.log(tag, 'Using EVM address for portfolio:', primaryAddress);
+
+  try {
+    let portfolio = await pioneer.GetPortfolio({ address: primaryAddress });
+    portfolio = portfolio.data;
+
+    if (!portfolio || !portfolio.balances) {
+      console.error(tag, 'No portfolio.balances found:', portfolio);
+      return balances;
+    }
+
+    // Process main balances
+    for (const balance of portfolio.balances) {
+      const processedBalance = processPortfolioBalance(balance, primaryAddress, context, blockchains);
+      if (processedBalance && !checkDuplicateBalance(balances, processedBalance.caip, processedBalance.pubkey)) {
+        balances.push(processedBalance);
+      }
+    }
+
+    // Process tokens from portfolio (if they exist)
+    if (portfolio.tokens && portfolio.tokens.length > 0) {
+      console.log(tag, 'Processing portfolio.tokens:', portfolio.tokens.length);
+      
+      for (const token of portfolio.tokens) {
+        const processedToken = processPortfolioToken(token, primaryAddress, context, blockchains);
+        if (processedToken && !checkDuplicateBalance(balances, processedToken.caip, processedToken.pubkey)) {
+          balances.push(processedToken);
+        }
+      }
+    }
+  } catch (e) {
+    console.error(tag, 'Error fetching portfolio:', e);
+  }
+
+  return balances;
+}
+
+function processPortfolioBalance(
+  balance: PortfolioBalance,
+  primaryAddress: string,
+  context: string,
+  blockchains: string[]
+): ChartBalance | null {
+  if (!balance.caip) {
+    console.error(tag, 'No caip found for:', balance);
+    return null;
+  }
+
+  // Always derive networkId from CAIP
+  const networkId = balance.caip.split('/')[0];
+  
+  // Skip if not in requested blockchains
+  if (!blockchains.includes(networkId)) {
+    return null;
+  }
+
+  // Hydrate with assetData
+  const assetInfo = hydrateAssetData(balance.caip);
+  
+  // CRITICAL FIX: Use the original balance.pubkey from API if it exists,
+  // otherwise fall back to primaryAddress. This ensures identifier consistency
+  // with regular balance fetching which uses the API's balance.pubkey value.
+  const balancePubkey = balance.pubkey || primaryAddress;
+  
+  // Determine if this is a token balance
+  const balanceType = assetInfo?.type || balance.type || 'native';
+  const isToken = balanceType !== 'native' && balance.caip.includes('/erc20:');
+  
+  // Calculate price from valueUsd and balance if not provided
+  let calculatedPrice = balance.priceUsd || balance.price || 0;
+  if ((!calculatedPrice || calculatedPrice === 0) && balance.valueUsd && balance.balance) {
+    const balanceNum = parseFloat(balance.balance.toString());
+    const valueNum = parseFloat(balance.valueUsd.toString());
+    if (balanceNum > 0 && valueNum > 0) {
+      calculatedPrice = valueNum / balanceNum;
+      console.log(tag, `Calculated price from value/balance: ${calculatedPrice} for ${balance.caip}`);
+    }
+  }
+
+  const chartBalance: ChartBalance = {
+    context,
+    chart: 'pioneer',
+    contextType: 'keepkey',
+    name: assetInfo?.name || balance.name || 'Unknown',
+    caip: balance.caip,
+    icon: assetInfo?.icon || balance.icon || '',
+    pubkey: balancePubkey,
+    ticker: assetInfo?.symbol || balance.symbol || 'UNK',
+    ref: `${context}${balance.caip}`,
+    identifier: createBalanceIdentifier(balance.caip, balancePubkey),
+    networkId,
+    chain: networkId,
+    symbol: assetInfo?.symbol || balance.symbol || 'UNK',
+    type: balanceType,
+    token: isToken,
+    decimal: assetInfo?.decimal || balance.decimal,
+    balance: balance.balance.toString(),
+    price: calculatedPrice,
+    priceUsd: calculatedPrice,
+    valueUsd: balance.valueUsd.toString(),
+    updated: new Date().getTime(),
+  };
+
+  // Handle display icon for multi-asset icons
+  if (balance.display) {
+    chartBalance.icon = ['multi', chartBalance.icon, balance.display.toString()].toString();
+  }
+
+  return chartBalance;
+}
+
+function processPortfolioToken(
+  token: PortfolioToken,
+  primaryAddress: string,
+  context: string,
+  blockchains: string[]
+): ChartBalance | null {
+  if (!token.assetCaip || !token.networkId) {
+    return null;
+  }
+
+  // Extract the networkId from the assetCaip for special token formats
+  let extractedNetworkId = token.networkId;
+  
+  // Special handling for tokens with special formats
+  if (token.assetCaip.includes('/denom:')) {
+    // Extract the network part before /denom:
+    const parts = token.assetCaip.split('/denom:');
+    if (parts.length > 0) {
+      extractedNetworkId = parts[0];
+    }
+  } else if (token.networkId && token.networkId.includes('/')) {
+    // For other tokens, split by / and take the first part
+    extractedNetworkId = token.networkId.split('/')[0];
+  }
+
+  // Skip if not in requested blockchains
+  if (!blockchains.includes(extractedNetworkId)) {
+    return null;
+  }
+
+  // Hydrate token with assetData
+  const tokenAssetInfo = hydrateAssetData(token.assetCaip);
+  
+  // CRITICAL FIX: Use consistent pubkey for tokens too
+  const tokenPubkey = token.pubkey || primaryAddress;
+
+  const chartBalance: ChartBalance = {
+    context,
+    chart: 'pioneer',
+    contextType: context.split(':')[0],
+    name: tokenAssetInfo?.name || token.token?.coingeckoId || token.token?.name || 'Unknown',
+    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 || 'token',
+    token: true,  // Tokens from portfolio.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/index.ts

@@ -0,0 +1,46 @@
+import { ChartBalance, ChartParams } from './types';
+import { getEvmCharts } from './evm';
+import { getMayaCharts } from './maya';
+import { getCosmosStakingCharts } from './cosmos-staking';
+
+const tag = '| getCharts |';
+const TIMEOUT = 30000;
+
+export const getCharts = async (
+  blockchains: any,
+  pioneer: any,
+  pubkeys: any,
+  context: string
+): Promise<ChartBalance[]> => {
+  try {
+    const balances: ChartBalance[] = [];
+    console.log(tag, 'init');
+    
+    const params: ChartParams = {
+      blockchains,
+      pioneer,
+      pubkeys,
+      context,
+    };
+
+    // Get EVM charts (includes portfolio and tokens)
+    const evmBalances = await getEvmCharts(params);
+    balances.push(...evmBalances);
+
+    // WORKAROUND: Check if MAYA tokens are missing and fetch them separately
+    const mayaBalances = await getMayaCharts(params, balances);
+    balances.push(...mayaBalances);
+
+    // Add Cosmos Staking Positions to charts
+    const stakingBalances = await getCosmosStakingCharts(params);
+    balances.push(...stakingBalances);
+
+    return balances;
+  } catch (error) {
+    console.error(tag, 'Error processing charts:', error);
+    throw error;
+  }
+};
+
+// Export types for external use
+export * from './types';

package/src/charts/maya.ts

@@ -0,0 +1,110 @@
+import { ChartBalance, ChartParams } from './types';
+import { hydrateAssetData, checkDuplicateBalance, createBalanceIdentifier } from './utils';
+
+const tag = '| charts-maya |';
+
+export async function getMayaCharts(
+  params: ChartParams,
+  existingBalances: ChartBalance[]
+): Promise<ChartBalance[]> {
+  const { blockchains, pioneer, pubkeys, context } = params;
+  const balances: ChartBalance[] = [];
+  
+  try {
+    // Check if we have a MAYA address
+    const mayaPubkey = pubkeys.find(
+      (p: any) =>
+        p.networks &&
+        Array.isArray(p.networks) &&
+        p.networks.includes('cosmos:mayachain-mainnet-v1'),
+    );
+    
+    if (!mayaPubkey || !mayaPubkey.address) {
+      console.log(tag, 'No MAYA pubkey found, skipping MAYA token fetch');
+      return balances;
+    }
+
+    // Check if MAYA network is in the requested blockchains
+    if (!blockchains.includes('cosmos:mayachain-mainnet-v1')) {
+      console.log(tag, 'MAYA network not in blockchains list, skipping MAYA token fetch');
+      return balances;
+    }
+
+    // Check if MAYA token is already in existing balances
+    const hasMayaToken = existingBalances.some(
+      (b: any) => b.caip === 'cosmos:mayachain-mainnet-v1/denom:maya',
+    );
+
+    if (hasMayaToken) {
+      console.log(tag, 'MAYA token already exists in balances, skipping');
+      return balances;
+    }
+
+    console.log(tag, 'MAYA token not found in portfolio, fetching separately...');
+    console.log(tag, 'MAYA pubkey address:', mayaPubkey.address);
+
+    // Try to get MAYA token balance via a separate call
+    // This is a workaround for the portfolio API not returning MAYA tokens
+    const mayaBalanceResponse = await pioneer.GetPortfolioBalances([
+      {
+        caip: 'cosmos:mayachain-mainnet-v1/denom:maya',
+        pubkey: mayaPubkey.address,
+      },
+    ]);
+
+    console.log(
+      tag,
+      'MAYA balance response:',
+      JSON.stringify(mayaBalanceResponse?.data, null, 2),
+    );
+
+    if (!mayaBalanceResponse?.data || mayaBalanceResponse.data.length === 0) {
+      console.log(tag, 'No MAYA token balance returned from GetPortfolioBalances API');
+      return balances;
+    }
+
+    console.log(tag, 'Found MAYA token balances:', mayaBalanceResponse.data.length);
+
+    for (const mayaBalance of mayaBalanceResponse.data) {
+      if (mayaBalance.caip !== 'cosmos:mayachain-mainnet-v1/denom:maya') {
+        console.log(tag, 'Unexpected balance in MAYA response:', mayaBalance);
+        continue;
+      }
+
+      // Hydrate MAYA token with assetData
+      const mayaAssetInfo = hydrateAssetData(mayaBalance.caip);
+
+      // CACAO is the native asset, MAYA is a token on the Maya chain
+      const isToken = mayaBalance.caip.includes('/denom:') && !mayaBalance.caip.endsWith('/denom:cacao');
+      
+      const mayaTokenBalance: ChartBalance = {
+        context,
+        chart: 'pioneer',
+        contextType: context.split(':')[0],
+        name: mayaAssetInfo?.name || 'Maya Token',
+        caip: mayaBalance.caip,
+        icon: mayaAssetInfo?.icon || 'https://pioneers.dev/coins/maya.png',
+        pubkey: mayaPubkey.address,
+        ticker: mayaAssetInfo?.symbol || 'MAYA',
+        ref: `${context}${mayaBalance.caip}`,
+        identifier: createBalanceIdentifier(mayaBalance.caip, mayaPubkey.address),
+        networkId: 'cosmos:mayachain-mainnet-v1',
+        symbol: mayaAssetInfo?.symbol || 'MAYA',
+        type: mayaAssetInfo?.type || 'token',
+        token: isToken,  // MAYA is a token, CACAO is the native asset
+        decimal: mayaAssetInfo?.decimal,
+        balance: mayaBalance.balance?.toString() || '0',
+        priceUsd: parseFloat(mayaBalance.priceUsd) || 0,
+        valueUsd: parseFloat(mayaBalance.valueUsd) || 0,
+        updated: new Date().getTime(),
+      };
+
+      console.log(tag, 'Adding MAYA token to balances:', mayaTokenBalance);
+      balances.push(mayaTokenBalance);
+    }
+  } catch (mayaError) {
+    console.error(tag, 'Error fetching MAYA token balance:', mayaError);
+  }
+
+  return balances;
+}

package/src/charts/types.ts

@@ -0,0 +1,77 @@
+export interface ChartBalance {
+  context: string;
+  chart: string;
+  contextType: string;
+  name: string;
+  caip: string;
+  icon: string;
+  pubkey: string;
+  ticker: string;
+  ref: string;
+  identifier: string;
+  networkId: string;
+  chain?: string;
+  symbol: string;
+  type: string;
+  token?: boolean;  // Indicates if this is a token balance
+  decimal?: number;
+  balance: string;
+  priceUsd: number;
+  valueUsd: number | string;
+  updated: number;
+  display?: string;
+  status?: string;
+  validator?: string;
+}
+
+export interface ChartParams {
+  blockchains: string[];
+  pioneer: any;
+  pubkeys: any[];
+  context: string;
+}
+
+export interface PortfolioBalance {
+  caip: string;
+  networkId?: string;
+  pubkey?: string;
+  balance: string | number;
+  valueUsd: string | number;
+  name?: string;
+  symbol?: string;
+  icon?: string;
+  decimal?: number;
+  type?: string;
+  display?: string;
+}
+
+export interface PortfolioToken {
+  assetCaip: string;
+  networkId?: string;
+  pubkey?: string;
+  token?: {
+    name?: string;
+    symbol?: string;
+    icon?: string;
+    coingeckoId?: string;
+    decimal?: number;
+    balance?: string | number;
+    price?: number;
+    balanceUSD?: number;
+  };
+}
+
+export interface StakingPosition {
+  caip: string;
+  balance: number;
+  priceUsd?: number;
+  valueUsd?: number;
+  name?: string;
+  icon?: string;
+  ticker?: string;
+  symbol?: string;
+  type?: string;
+  status?: string;
+  validatorAddress?: string;
+  validator?: string;
+}

package/src/charts/utils.ts

@@ -0,0 +1,24 @@
+import { assetData } from '@pioneer-platform/pioneer-discovery';
+import { ChartBalance } from './types';
+
+export function hydrateAssetData(caip: string): any {
+  return assetData[caip] || assetData[caip.toLowerCase()];
+}
+
+export function checkDuplicateBalance(
+  balances: ChartBalance[],
+  caip: string,
+  pubkey: string,
+  validator?: string
+): boolean {
+  return balances.some(
+    (b) =>
+      b.caip === caip &&
+      b.pubkey === pubkey &&
+      (!validator || b.validator === validator)
+  );
+}
+
+export function createBalanceIdentifier(caip: string, pubkey: string): string {
+  return `${caip}:${pubkey}`;
+}