@pioneer-platform/pioneer-sdk 0.0.82 → 4.13.30

package/package.json

@@ -1,43 +1,61 @@
 {
+  "author": "highlander",
   "name": "@pioneer-platform/pioneer-sdk",
-  "version": "0.0.82",
-  "main": "./lib/index.js",
-  "types": "./lib/index.d.ts",
-  "scripts": {
-    "npm": "npm i",
-    "npm-update": "npm update",
-    "test": "npm run build && node __tests__/test-module.js",
-    "test-ts": "rm -R lib && npm run build && ts-node __tests__/test-module-ts.ts",
-    "lint": "prettier --write '**/**/*.ts'",
-    "start": "nodemon --watch 'src/**/*.ts' --exec ts-node __tests__node",
-    "build": "tsc -p .",
-    "prepublish": "npm run build",
-    "refresh": "rm -rf ./node_modules ./package-lock.json && npm install",
-    "test-jest": "jest --coverage",
-    "test:watch": "jest --coverage --watchAll",
-    "build:watch": "onchange 'src/**/*.ts' -- npm run build",
-    "view:coverage": "serve coverage/lcov-report",
-    "clean": "rm -rf coverage src/**/*.js src/**/*.map lib node_modules"
-  },
+  "version": "4.13.30",
   "dependencies": {
-    "@pioneer-platform/pioneer-coins": "latest",
-    "@pioneer-platform/pioneer-events": "latest",
-    "@pioneer-platform/pioneer-xchain-client": "latest",
-    "bignumber.js": "^9.0.1",
-    "dotenv": "^8.2.0",
-    "openapi-client-axios": "^3.13.1",
-    "prettyjson": "^1.2.1",
-    "ts-node": "^9.1.1"
+    "@keepkey/keepkey-sdk": "^0.2.62",
+    "@pioneer-platform/loggerdog": "^8.4.1",
+    "@pioneer-platform/pioneer-caip": "^9.3.1",
+    "@pioneer-platform/pioneer-client": "^9.3.1",
+    "@pioneer-platform/pioneer-coins": "^9.4.1",
+    "@pioneer-platform/pioneer-discovery": "^0.1.1",
+    "@pioneer-platform/pioneer-events": "^8.4.1",
+    "coinselect": "^3.1.13",
+    "eventemitter3": "^5.0.1",
+    "neotraverse": "^0.6.8"
   },
+  "description": "Pioneer Core SDK",
   "devDependencies": {
-    "@types/jest": "^25.2.3",
-    "@types/node": "^13.13.51",
-    "@types/source-map-support": "^0.5.3",
-    "jest": "^26.6.3",
-    "onchange": "^7.1.0",
-    "serve": "^11.3.2",
-    "source-map-support": "^0.5.19",
-    "ts-jest": "^25.4.0",
-    "typescript": "^3.9.9"
-  }
+    "@types/bn.js": "5.1.5",
+    "@types/crypto-js": "4.2.1",
+    "@types/elliptic": "6.4.18",
+    "@types/long": "4.0.2",
+    "@types/node": "20.10.0",
+    "@types/tiny-secp256k1": "1.0.0",
+    "@vitest/coverage-istanbul": "0.34.6",
+    "vitest": "0.34.6"
+  },
+  "eslintConfig": {
+    "extends": "../../../internal/eslint-config"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "src/",
+    "dist/"
+  ],
+  "homepage": "https://github.com/thorswap/SwapKit",
+  "license": "GPL-3.0",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.es.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "react-native": "./src/index.ts",
+  "repository": "https://github.com/thorswap/SwapKit.git",
+  "scripts": {
+    "build": "bash scripts/build.sh",
+    "build:watch": "nodemon --watch src --exec 'bun run build'",
+    "clean": "rm -rf dist .turbo node_modules",
+    "lint": "eslint ./ --ext .ts,.tsx --fix; tsc --noEmit",
+    "test": "echo 'vitest --run'",
+    "test:coverage": "echo 'vitest run --coverage'"
+  },
+  "type": "module",
+  "types": "./dist/index.d.ts"
 }

package/src/TransactionManager.ts

@@ -0,0 +1,333 @@
+/*
+    Tx Manager
+*/
+import type EventEmitter from 'events';
+
+import { CAIP_TO_COIN_MAP, SUPPORTED_CAIPS } from './supportedCaips';
+import { createUnsignedEvmTx } from './txbuilder/createUnsignedEvmTx';
+import { createUnsignedRippleTx } from './txbuilder/createUnsignedRippleTx';
+import { createUnsignedTendermintTx } from './txbuilder/createUnsignedTendermintTx';
+import { createUnsignedUxtoTx } from './txbuilder/createUnsignedUxtoTx';
+
+const TAG = ' | Transaction | ';
+
+interface TransactionDependencies {
+  context: string;
+  assetContext: any;
+  balances: any[];
+  pubkeys: any[];
+  nodes: any[];
+  pioneer: any;
+  keepKeySdk: any;
+}
+
+export class TransactionManager {
+  private context: string;
+  private assetContext: any;
+  private balances: any[];
+  private pubkeys: any[];
+  private nodes: any[];
+  private pioneer: any;
+  private keepKeySdk: any;
+  private events: EventEmitter;
+
+  constructor(dependencies: TransactionDependencies, events: EventEmitter) {
+    this.context = dependencies.context;
+    this.assetContext = dependencies.assetContext;
+    this.balances = dependencies.balances;
+    this.pubkeys = dependencies.pubkeys;
+    this.nodes = dependencies.nodes;
+    this.pioneer = dependencies.pioneer;
+    this.keepKeySdk = dependencies.keepKeySdk;
+    this.events = events;
+  }
+
+  async classifyCaip(caip: string): Promise<string> {
+    if (SUPPORTED_CAIPS.UTXO.includes(caip)) return 'UTXO';
+    if (SUPPORTED_CAIPS.TENDERMINT.includes(caip)) return 'TENDERMINT';
+    if (caip.startsWith('eip155')) return 'EIP155';
+    if (SUPPORTED_CAIPS.OTHER.includes(caip)) return 'OTHER';
+    throw new Error(`Unsupported CAIP: ${caip}`);
+  }
+
+  async transfer({ caip, to, amount, memo, isMax = false, feeLevel = 5, changeScriptType }: any): Promise<any> {
+    let tag = TAG + ' | transfer | ';
+    try {
+      if (!this.pioneer) throw Error('Failed to init! pioneer');
+      if (!caip) throw Error('Missing required param! caip');
+      if (!to) throw Error('Missing required param! to');
+      if (!amount) throw Error('Missing required param! amount');
+      if (!memo) memo = ' ';
+      const type = await this.classifyCaip(caip);
+
+      let unsignedTx;
+      switch (type) {
+        case 'UTXO': {
+          unsignedTx = await createUnsignedUxtoTx(
+            caip,
+            to,
+            amount,
+            memo,
+            this.pubkeys,
+            this.pioneer,
+            this.keepKeySdk,
+            isMax,
+            feeLevel,
+            changeScriptType,
+          );
+          break;
+        }
+        case 'TENDERMINT': {
+          const txType = 'transfer';
+          unsignedTx = await createUnsignedTendermintTx(
+            caip,
+            txType,
+            amount,
+            memo,
+            this.pubkeys,
+            this.pioneer,
+            this.keepKeySdk,
+            isMax,
+            to,
+          );
+          break;
+        }
+        case 'EIP155': {
+          unsignedTx = await createUnsignedEvmTx(
+            caip,
+            to,
+            amount,
+            memo,
+            this.pubkeys,
+            this.pioneer,
+            this.keepKeySdk,
+            isMax,
+            feeLevel,
+          );
+          break;
+        }
+        case 'OTHER': {
+          unsignedTx = await createUnsignedRippleTx(
+            caip,
+            to,
+            amount,
+            memo,
+            this.pubkeys,
+            this.pioneer,
+            this.keepKeySdk,
+            isMax,
+          );
+          break;
+        }
+        default: {
+          throw new Error(`Unsupported CAIP: ${caip}`);
+        }
+      }
+
+      return unsignedTx;
+    } catch (e: any) {
+      console.error(tag, e);
+      throw e;
+    }
+  }
+
+  async sign({ caip, unsignedTx }: any): Promise<any> {
+    let tag = TAG + ' | sign | ';
+    try {
+      if (!this.pioneer) throw Error('Failed to init! pioneer');
+
+
+      const type = await this.classifyCaip(caip);
+      let signedTx: any;
+
+      switch (type) {
+        case 'UTXO': {
+          const coin = CAIP_TO_COIN_MAP[caip];
+          if (!coin) throw Error(`Unsupported UTXO coin type for CAIP: ${caip}`);
+
+          const signPayload: any = {
+            coin,
+            inputs: unsignedTx.inputs,
+            outputs: unsignedTx.outputs,
+            version: 1,
+            locktime: 0,
+            // opReturnData: unsignedTx.memo,
+          };
+          if (unsignedTx.memo && unsignedTx.memo !== ' ') {
+            signPayload.opReturnData = unsignedTx.memo;
+          }
+
+          const responseSign = await this.keepKeySdk.utxo.utxoSignTransaction(signPayload);
+          signedTx = responseSign.serializedTx;
+          break;
+        }
+        case 'TENDERMINT': {
+          switch (caip) {
+            case 'cosmos:cosmoshub-4/slip44:118': {
+              const msgType = unsignedTx.signDoc.msgs[0].type;
+              if (msgType === 'cosmos-sdk/MsgSend') {
+                const responseSign = await this.keepKeySdk.cosmos.cosmosSignAmino(unsignedTx);
+                signedTx = responseSign.serialized;
+              } else if (msgType === 'cosmos-sdk/MsgDelegate') {
+                const responseSign =
+                  await this.keepKeySdk.cosmos.cosmosSignAminoDelegate(unsignedTx);
+                signedTx = responseSign.serialized;
+              } else if (msgType === 'cosmos-sdk/MsgUndelegate') {
+                const responseSign =
+                  await this.keepKeySdk.cosmos.cosmosSignAminoUndelegate(unsignedTx);
+                signedTx = responseSign.serialized;
+              } else if (msgType === 'cosmos-sdk/MsgBeginRedelegate') {
+                const responseSign =
+                  await this.keepKeySdk.cosmos.cosmosSignAminoRedelegate(unsignedTx);
+                signedTx = responseSign.serialized;
+              } else if (msgType === 'cosmos-sdk/MsgWithdrawDelegationReward') {
+                const responseSign =
+                  await this.keepKeySdk.cosmos.cosmosSignAminoWithdrawDelegatorRewardsAll(
+                    unsignedTx,
+                  );
+                signedTx = responseSign.serialized;
+              } else {
+                throw new Error(`Unsupported CosmosHub message type: ${msgType}`);
+              }
+              break;
+            }
+            case 'cosmos:osmosis-1/slip44:118': {
+              const msgType = unsignedTx.signDoc.msgs[0].type;
+              if (msgType === 'cosmos-sdk/MsgSend') {
+                const responseSign = await this.keepKeySdk.osmosis.osmosisSignAmino(unsignedTx);
+                signedTx = responseSign.serialized;
+              } else if (msgType === 'cosmos-sdk/MsgDelegate') {
+                const responseSign =
+                  await this.keepKeySdk.osmosis.osmoSignAminoDelegate(unsignedTx);
+                signedTx = responseSign.serialized;
+              } else if (msgType === 'cosmos-sdk/MsgUndelegate') {
+                const responseSign =
+                  await this.keepKeySdk.osmosis.osmoSignAminoUndelegate(unsignedTx);
+                signedTx = responseSign.serialized;
+              } else if (msgType === 'cosmos-sdk/MsgBeginRedelegate') {
+                const responseSign =
+                  await this.keepKeySdk.osmosis.osmoSignAminoRedelegate(unsignedTx);
+                signedTx = responseSign.serialized;
+              } else if (msgType === 'cosmos-sdk/MsgWithdrawDelegationReward') {
+                const responseSign =
+                  await this.keepKeySdk.osmosis.osmoSignAminoWithdrawDelegatorRewardsAll(
+                    unsignedTx,
+                  );
+                signedTx = responseSign.serialized;
+              } else {
+                throw new Error(`Unsupported Osmosis message type: ${msgType}`);
+              }
+              break;
+            }
+            case 'cosmos:thorchain-mainnet-v1/slip44:931': {
+              if (unsignedTx.signDoc.msgs[0].type === 'thorchain/MsgSend') {
+                const responseSign =
+                  await this.keepKeySdk.thorchain.thorchainSignAminoTransfer(unsignedTx);
+                signedTx = responseSign.serialized;
+              } else if (unsignedTx.signDoc.msgs[0].type === 'thorchain/MsgDeposit') {
+                const responseSign =
+                  await this.keepKeySdk.thorchain.thorchainSignAminoDeposit(unsignedTx);
+                signedTx = responseSign.serialized;
+              } else {
+                throw new Error(
+                  `Unsupported Thorchain message type: ${unsignedTx.signDoc.msgs[0].type}`,
+                );
+              }
+              break;
+            }
+            case 'cosmos:mayachain-mainnet-v1/slip44:931':
+            case 'cosmos:mayachain-mainnet-v1/denom:maya': {
+              if (unsignedTx.signDoc.msgs[0].type === 'mayachain/MsgSend') {
+                const responseSign =
+                  await this.keepKeySdk.mayachain.mayachainSignAminoTransfer(unsignedTx);
+                signedTx = responseSign.serialized;
+              } else if (unsignedTx.signDoc.msgs[0].type === 'mayachain/MsgDeposit') {
+                const responseSign =
+                  await this.keepKeySdk.mayachain.mayachainSignAminoDeposit(unsignedTx);
+                signedTx = responseSign.serialized;
+              } else {
+                throw new Error(
+                  `Unsupported mayachain message type: ${unsignedTx.signDoc.msgs[0].type}`,
+                );
+              }
+              break;
+            }
+            default: {
+              throw new Error(`Unsupported Tendermint CAIP: ${caip}`);
+            }
+          }
+          break;
+        }
+        case 'EIP155': {
+
+          const responseSign = await this.keepKeySdk.eth.ethSignTransaction(unsignedTx);
+          if (responseSign?.serialized) {
+            const serialized = responseSign.serialized;
+            if (serialized.length > 140) {
+              signedTx = serialized;
+            } else {
+              console.error(
+                tag,
+                'EIP155 signing returned incomplete transaction - only signature components',
+              );
+              throw new Error(
+                'KeepKey returned incomplete transaction - cannot reconstruct without r,s,v components',
+              );
+            }
+          } else {
+            console.error(
+              tag,
+              'EIP155 signing failed - no valid signature in response:',
+              responseSign,
+            );
+            throw new Error('Failed to sign transaction - no valid signature in response');
+          }
+          break;
+        }
+        case 'OTHER': {
+          if (caip === 'ripple:4109c6f2045fc7eff4cde8f9905d19c2/slip44:144') {
+            let responseSign = await this.keepKeySdk.xrp.xrpSignTransaction(unsignedTx);
+            if (typeof responseSign === 'string') responseSign = JSON.parse(responseSign);
+            signedTx = responseSign.value.signatures[0].serializedTx;
+          } else {
+            throw new Error(`Unsupported OTHER CAIP: ${caip}`);
+          }
+          break;
+        }
+        default: {
+          throw new Error(`Unsupported CAIP: ${caip}`);
+        }
+      }
+
+      if (!signedTx) {
+        console.error(tag, 'CRITICAL ERROR: signedTx is missing after signing process');
+        console.error(tag, 'CAIP:', caip);
+        console.error(tag, 'Type:', type);
+        throw Error('Failed to sign! missing signedTx');
+      }
+      return signedTx;
+    } catch (e: any) {
+      console.error(tag, e);
+      throw e;
+    }
+  }
+
+  async broadcast({ networkId, serialized }: any): Promise<any> {
+    let tag = TAG + ' | broadcast | ';
+    try {
+      if (!this.pioneer) throw Error('Failed to init! pioneer');
+      if (!serialized) throw Error('Failed to broadcast! missing serialized2');
+      let result = await this.pioneer.Broadcast({ networkId, serialized });
+      result = result.data;
+      if (result.error) {
+        // Throw an error instead of returning the error object
+        throw new Error(`Broadcast failed: ${result.error}`);
+      } else {
+        return result.txid;
+      }
+    } catch (e: any) {
+      console.error(tag, e);
+      throw e;
+    }
+  }
+}

package/src/charts/cosmos-staking.ts

@@ -0,0 +1,171 @@
+import { ChartBalance, ChartParams, StakingPosition } from './types';
+import { hydrateAssetData, checkDuplicateBalance, createBalanceIdentifier } from './utils';
+
+const tag = '| charts-cosmos-staking |';
+
+export async function getCosmosStakingCharts(params: ChartParams): Promise<ChartBalance[]> {
+  const { blockchains, pioneer, pubkeys, context } = params;
+  const balances: ChartBalance[] = [];
+  
+  try {
+    console.log(tag, 'Adding Cosmos staking positions to charts...');
+
+    // Find cosmos pubkeys that could have staking positions
+    const cosmosPubkeys = pubkeys.filter(
+      (p: any) =>
+        p.networks &&
+        Array.isArray(p.networks) &&
+        p.networks.some(
+          (n: string) => n.includes('cosmos:cosmoshub') || n.includes('cosmos:osmosis'),
+        ),
+    );
+
+    if (cosmosPubkeys.length === 0) {
+      console.log(tag, 'No cosmos pubkeys found for staking positions');
+      return balances;
+    }
+
+    console.log(tag, 'Found cosmos pubkeys for staking:', cosmosPubkeys.length);
+
+    for (const cosmosPubkey of cosmosPubkeys) {
+      if (!cosmosPubkey.address) {
+        continue;
+      }
+
+      // Check which cosmos networks this pubkey supports
+      const cosmosNetworks = cosmosPubkey.networks.filter(
+        (n: string) => n.includes('cosmos:cosmoshub') || n.includes('cosmos:osmosis'),
+      );
+
+      for (const networkId of cosmosNetworks) {
+        // Only process if this network is in our blockchains list
+        if (!blockchains.includes(networkId)) {
+          continue;
+        }
+
+        await fetchStakingPositionsForNetwork(
+          networkId,
+          cosmosPubkey.address,
+          context,
+          pioneer,
+          balances
+        );
+      }
+    }
+  } catch (e) {
+    console.error(tag, 'Error adding cosmos staking positions:', e);
+  }
+
+  return balances;
+}
+
+async function fetchStakingPositionsForNetwork(
+  networkId: string,
+  address: string,
+  context: string,
+  pioneer: any,
+  balances: ChartBalance[]
+): Promise<void> {
+  try {
+    console.log(tag, `Fetching staking positions for ${address} on ${networkId}...`);
+
+    // Convert networkId to network name for API
+    let network: string;
+    if (networkId === 'cosmos:cosmoshub-4') {
+      network = 'cosmos';
+    } else if (networkId === 'cosmos:osmosis-1') {
+      network = 'osmosis';
+    } else {
+      console.error(tag, `Unsupported networkId for staking: ${networkId}`);
+      return;
+    }
+
+    // Get staking positions from pioneer server
+    const stakingResponse = await pioneer.GetStakingPositions({
+      network,
+      address,
+    });
+
+    if (!stakingResponse?.data || !Array.isArray(stakingResponse.data)) {
+      console.log(tag, `No staking positions found for ${address} on ${networkId}`);
+      return;
+    }
+
+    console.log(
+      tag,
+      `Found ${stakingResponse.data.length} staking positions for ${networkId}`,
+    );
+
+    for (const position of stakingResponse.data) {
+      const processedPosition = processStakingPosition(
+        position,
+        address,
+        context,
+        networkId
+      );
+      
+      if (processedPosition && !checkDuplicateBalance(
+        balances,
+        processedPosition.caip,
+        processedPosition.pubkey,
+        processedPosition.validator
+      )) {
+        balances.push(processedPosition);
+        console.log(tag, `Added ${position.type} position:`, {
+          balance: processedPosition.balance,
+          ticker: processedPosition.ticker,
+          valueUsd: processedPosition.valueUsd,
+          validator: processedPosition.validator,
+        });
+      }
+    }
+  } catch (stakingError) {
+    console.error(
+      tag,
+      `Error fetching staking positions for ${address} on ${networkId}:`,
+      stakingError,
+    );
+  }
+}
+
+function processStakingPosition(
+  position: StakingPosition,
+  address: string,
+  context: string,
+  networkId: string
+): ChartBalance | null {
+  // Validate position has required fields
+  if (!position.balance || position.balance <= 0 || !position.caip) {
+    return null;
+  }
+
+  // Hydrate staking position with assetData
+  const stakingAssetInfo = hydrateAssetData(position.caip);
+
+  // Staking positions are not tokens, they represent staked native assets
+  const stakingBalance: ChartBalance = {
+    context,
+    chart: 'staking',
+    contextType: context.split(':')[0],
+    name: stakingAssetInfo?.name || position.name || `${position.type} Position`,
+    caip: position.caip,
+    icon: stakingAssetInfo?.icon || position.icon || '',
+    pubkey: address,
+    ticker: stakingAssetInfo?.symbol || position.ticker || position.symbol || 'UNK',
+    ref: `${context}${position.caip}`,
+    identifier: createBalanceIdentifier(position.caip, address),
+    networkId,
+    symbol: stakingAssetInfo?.symbol || position.symbol || position.ticker || 'UNK',
+    type: stakingAssetInfo?.type || position.type || 'staking',
+    token: false,  // Staking positions are not tokens
+    decimal: stakingAssetInfo?.decimal,
+    balance: position.balance.toString(),
+    priceUsd: position.priceUsd || 0,
+    valueUsd: position.valueUsd || position.balance * (position.priceUsd || 0),
+    status: position.status || 'active',
+    validator: position.validatorAddress || position.validator || '',
+    updated: new Date().getTime(),
+  };
+
+  return stakingBalance;
+}