@ledgerhq/coin-tron 5.6.0-nightly.4 → 5.6.0-nightly.6

package/src/bridge/getEstimateFees.test.ts

@@ -6,15 +6,18 @@ import { ACTIVATION_FEES, STANDARD_FEES_NATIVE, STANDARD_FEES_TRC_20 } from "../
 import { Account, TokenAccount } from "@ledgerhq/types-live";
 import { Transaction } from "../types";
 
+// Mock typed functions
+const mockGetAccount = jest.mocked(getAccount);
+const mockEstimateFees = jest.mocked(estimateFees);
+const mockExtractBandwidthInfo = jest.mocked(extractBandwidthInfo);
+
 jest.mock("./utils", () => ({
   extractBandwidthInfo: jest.fn(),
   getEstimatedBlockSize: jest.fn().mockReturnValue(new BigNumber(200)),
 }));
 
-jest.mock("../logic", () => ({
-  estimateFees: jest.fn(),
-  getAccount: jest.fn(),
-}));
+jest.mock("../logic/estimateFees");
+jest.mock("../logic/getAccount");
 
 describe("getEstimatedFees", () => {
   const mockAccount = {
@@ -56,8 +59,8 @@ describe("getEstimatedFees", () => {
 
   describe("getFeesFromBandwidth", () => {
     it("should return STANDARD_FEES_NATIVE if bandwidth is insufficient", async () => {
-      (getAccount as jest.Mock).mockResolvedValue([{ address: "mock-contract-address" }]);
-      (extractBandwidthInfo as jest.Mock).mockReturnValue({
+      mockGetAccount.mockResolvedValue([{ address: "mock-contract-address", trc20: [] }]);
+      mockExtractBandwidthInfo.mockReturnValue({
         freeUsed: new BigNumber(0),
         freeLimit: new BigNumber(0),
         gainedUsed: new BigNumber(0),
@@ -69,8 +72,8 @@ describe("getEstimatedFees", () => {
     });
 
     it("should return 0 if bandwidth is sufficient", async () => {
-      (getAccount as jest.Mock).mockResolvedValue([{ address: "mock-contract-address" }]);
-      (extractBandwidthInfo as jest.Mock).mockReturnValue({
+      mockGetAccount.mockResolvedValue([{ address: "mock-contract-address", trc20: [] }]);
+      mockExtractBandwidthInfo.mockReturnValue({
         freeUsed: new BigNumber(0),
         freeLimit: new BigNumber(500),
         gainedUsed: new BigNumber(0),
@@ -84,8 +87,10 @@ describe("getEstimatedFees", () => {
 
   describe("getFeesFromAccountActivation", () => {
     it("should return ACTIVATION_FEES if recipient account is not active", async () => {
-      (getAccount as jest.Mock).mockResolvedValue([]);
-      (extractBandwidthInfo as jest.Mock).mockReturnValue({
+      mockGetAccount.mockResolvedValue([]);
+      mockExtractBandwidthInfo.mockReturnValue({
+        freeUsed: new BigNumber(0),
+        freeLimit: new BigNumber(0),
         gainedUsed: new BigNumber(0),
         gainedLimit: new BigNumber(0),
       });
@@ -95,8 +100,10 @@ describe("getEstimatedFees", () => {
     });
 
     it("should return STANDARD_FEES_TRC_20 if recipient has TRC20 balance", async () => {
-      (getAccount as jest.Mock).mockResolvedValue([{ address: "mock-contract-address" }]);
-      (extractBandwidthInfo as jest.Mock).mockReturnValue({
+      mockGetAccount.mockResolvedValue([{ address: "mock-contract-address", trc20: [] }]);
+      mockExtractBandwidthInfo.mockReturnValue({
+        freeUsed: new BigNumber(0),
+        freeLimit: new BigNumber(0),
         gainedUsed: new BigNumber(0),
         gainedLimit: new BigNumber(500),
       });
@@ -106,9 +113,11 @@ describe("getEstimatedFees", () => {
     });
 
     it("should return estimated fees for TRC20 token transfer", async () => {
-      (getAccount as jest.Mock).mockResolvedValue([]);
-      (estimateFees as jest.Mock).mockResolvedValue(new BigNumber(1000));
-      (extractBandwidthInfo as jest.Mock).mockReturnValue({
+      mockGetAccount.mockResolvedValue([]);
+      mockEstimateFees.mockResolvedValue(1000n);
+      mockExtractBandwidthInfo.mockReturnValue({
+        freeUsed: new BigNumber(0),
+        freeLimit: new BigNumber(0),
         gainedUsed: new BigNumber(0),
         gainedLimit: new BigNumber(0),
       });
@@ -120,8 +129,8 @@ describe("getEstimatedFees", () => {
 
   describe("getEstimatedFees", () => {
     it("should prioritize account activation fees over bandwidth fees", async () => {
-      (getAccount as jest.Mock).mockResolvedValue([]);
-      (extractBandwidthInfo as jest.Mock).mockReturnValue({
+      mockGetAccount.mockResolvedValue([]);
+      mockExtractBandwidthInfo.mockReturnValue({
         freeUsed: new BigNumber(0),
         freeLimit: new BigNumber(0),
         gainedUsed: new BigNumber(0),
@@ -133,8 +142,8 @@ describe("getEstimatedFees", () => {
     });
 
     it("should return bandwidth fees if no account activation is required", async () => {
-      (getAccount as jest.Mock).mockResolvedValue([{ trc20: [] }]);
-      (extractBandwidthInfo as jest.Mock).mockReturnValue({
+      mockGetAccount.mockResolvedValue([{ address: "mock-address", trc20: [] }]);
+      mockExtractBandwidthInfo.mockReturnValue({
         freeUsed: new BigNumber(0),
         freeLimit: new BigNumber(500),
         gainedUsed: new BigNumber(0),

package/src/bridge/synchronization.integ.test.ts

@@ -1,4 +1,4 @@
-import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/index";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
 import { Account, AccountBridge, SyncConfig, TransactionCommon } from "@ledgerhq/types-live";
 import BigNumber from "bignumber.js";
 import { firstValueFrom, reduce } from "rxjs";

package/src/bridge/synchronization.test.ts

@@ -1,5 +1,5 @@
 import { makeScanAccounts } from "@ledgerhq/coin-framework/bridge/jsHelpers";
-import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/index";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
 import { Account, AccountBridge, SyncConfig, TransactionCommon } from "@ledgerhq/types-live";
 import BigNumber from "bignumber.js";
 import { firstValueFrom, reduce } from "rxjs";
@@ -12,6 +12,9 @@ import { createBridges } from "./index";
 import { getAccountShape } from "./synchronization";
 import { setupServer } from "msw/node";
 import { AccountTronAPI } from "../network/types";
+import { getCryptoAssetsStore } from "@ledgerhq/coin-framework/crypto-assets/index";
+
+jest.mock("@ledgerhq/coin-framework/crypto-assets/index");
 
 const currency = getCryptoCurrencyById("tron");
 const defaultSyncConfig = {
@@ -115,6 +118,88 @@ describe("sync", () => {
   let bridge: ReturnType<typeof createBridges>;
 
   beforeAll(() => {
+    // Mock the crypto assets store with the expected tokens
+    const parentCurrency = {
+      type: "CryptoCurrency",
+      id: "tron",
+      coinType: 195,
+      name: "Tron",
+      managerAppName: "Tron",
+      ticker: "TRX",
+      scheme: "tron",
+      color: "#D9012C",
+      family: "tron",
+      blockAvgTime: 9,
+      units: [{ name: "TRX", code: "TRX", magnitude: 6 }],
+      explorerViews: [
+        {
+          tx: "https://tronscan.org/#/transaction/$hash",
+          address: "https://tronscan.org/#/address/$address",
+        },
+      ],
+      keywords: ["trx", "tron"],
+    };
+
+    const mockTokens = {
+      "tron/trc10/1002000": {
+        type: "TokenCurrency",
+        id: "tron/trc10/1002000",
+        contractAddress: "TF5Bn4cJCT6GVeUgyCN4rBhDg42KBrpAjg",
+        parentCurrency,
+        tokenType: "trc10",
+        name: "BitTorrent Old",
+        ticker: "BTTOLD",
+        delisted: true,
+        disableCountervalue: false,
+        ledgerSignature:
+          "0a0a426974546f7272656e7410061a46304402202e2502f36b00e57be785fc79ec4043abcdd4fdd1b58d737ce123599dffad2cb602201702c307f009d014a553503b499591558b3634ceee4c054c61cedd8aca94c02b",
+        units: [{ name: "BitTorrent Old", code: "BTTOLD", magnitude: 6 }],
+      },
+      "tron/trc20/tla2f6vpqdgre67v1736s7bj8ray5wyju7": {
+        type: "TokenCurrency",
+        id: "tron/trc20/tla2f6vpqdgre67v1736s7bj8ray5wyju7",
+        contractAddress: "TLa2f6VPqDgRE67v1736s7bJ8Ray5wYjU7",
+        parentCurrency,
+        tokenType: "trc20",
+        name: "WINK",
+        ticker: "WIN",
+        delisted: false,
+        disableCountervalue: false,
+        ledgerSignature: null,
+        units: [{ name: "WINK", code: "WIN", magnitude: 6 }],
+      },
+      "tron/trc20/tcfll5dx5zjdknwuesxxi1vpwjlvmwzzy9": {
+        type: "TokenCurrency",
+        id: "tron/trc20/tcfll5dx5zjdknwuesxxi1vpwjlvmwzzy9",
+        contractAddress: "TCFLL5dx5ZJdKnWuesXxi1VPwjLVmWZZy9",
+        parentCurrency,
+        tokenType: "trc20",
+        name: "JUST GOV",
+        ticker: "JST",
+        delisted: false,
+        disableCountervalue: false,
+        ledgerSignature: null,
+        units: [{ name: "JUST GOV", code: "JST", magnitude: 18 }],
+      },
+    };
+
+    (getCryptoAssetsStore as jest.Mock).mockReturnValue({
+      findTokenById: jest.fn().mockImplementation((id: string) => {
+        return Promise.resolve(mockTokens[id as keyof typeof mockTokens] || null);
+      }),
+      findTokenByAddressInCurrency: jest
+        .fn()
+        .mockImplementation((address: string, currencyId: string) => {
+          if (currencyId === "tron") {
+            const token = Object.values(mockTokens).find(
+              token => token.contractAddress.toLowerCase() === address.toLowerCase(),
+            );
+            return Promise.resolve(token || null);
+          }
+          return Promise.resolve(null);
+        }),
+    });
+
     const signer = jest.fn();
     const coinConfig = (): TronCoinConfig => ({
       status: {
@@ -163,6 +248,12 @@ describe("scanAccounts", () => {
   beforeAll(() => {
     spyGetTronAccountNetwork = jest.spyOn(tronNetwork, "getTronAccountNetwork");
 
+    // Mock the crypto assets store for scanAccounts tests - same as sync tests
+    (getCryptoAssetsStore as jest.Mock).mockReturnValue({
+      findTokenById: jest.fn().mockResolvedValue(null),
+      findTokenByAddressInCurrency: jest.fn().mockResolvedValue(null),
+    });
+
     coinConfig.setCoinConfig(() => ({
       status: {
         type: "active",

package/src/bridge/synchronization.ts

@@ -5,7 +5,7 @@ import {
 } from "@ledgerhq/coin-framework/account";
 import { GetAccountShape, makeSync } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
-import { findTokenByAddressInCurrency, findTokenById } from "@ledgerhq/cryptoassets/index";
+import { getCryptoAssetsStore } from "@ledgerhq/coin-framework/crypto-assets/index";
 import { Account, TokenAccount } from "@ledgerhq/types-live";
 import BigNumber from "bignumber.js";
 import compact from "lodash/compact";
@@ -22,6 +22,7 @@ import {
   isAccountEmpty,
 } from "./utils";
 import { getAccount } from "../logic/getAccount";
+import { AccountTronAPI } from "../network/types";
 
 type TronToken = {
   key: string;
@@ -32,6 +33,43 @@ type TronToken = {
 
 // the balance does not update straightaway so we should ignore recent operations if they are in pending for a bit
 const PREFER_PENDING_OPERATIONS_UNTIL_BLOCK_VALIDATION = 35;
+const MAX_OPERATIONS_PAGE_SIZE = 1000;
+
+async function getTrc10Tokens(acc: AccountTronAPI): Promise<TronToken[]> {
+  const trc10Tokens: TronToken[] = [];
+  for (const { key, value } of get(acc, "assetV2", []) as { key: string; value: number }[]) {
+    const tokenInfo = await getCryptoAssetsStore().findTokenById(`tron/trc10/${key}`);
+    if (tokenInfo) {
+      trc10Tokens.push({
+        key,
+        type: "trc10",
+        tokenId: tokenInfo.id,
+        balance: value.toString(),
+      });
+    }
+  }
+  return trc10Tokens;
+}
+
+async function getTrc20Tokens(acc: AccountTronAPI, currencyId: string): Promise<TronToken[]> {
+  const trc20Tokens: TronToken[] = [];
+  for (const trc20 of get(acc, "trc20", []) as Record<string, string>[]) {
+    const [[contractAddress, balance]] = Object.entries(trc20);
+    const tokenInfo = await getCryptoAssetsStore().findTokenByAddressInCurrency(
+      contractAddress,
+      currencyId,
+    );
+    if (tokenInfo) {
+      trc20Tokens.push({
+        key: contractAddress,
+        type: "trc20",
+        tokenId: tokenInfo.id,
+        balance,
+      });
+    }
+  }
+  return trc20Tokens;
+}
 
 export const getAccountShape: GetAccountShape<TronAccount> = async (
   { initialAccount, currency, address, derivationMode },
@@ -58,14 +96,10 @@ export const getAccountShape: GetAccountShape<TronAccount> = async (
   }
 
   const acc = tronAcc[0];
-  const cacheTransactionInfoById = initialAccount
-    ? {
-        ...(initialAccount?.tronResources?.cacheTransactionInfoById || {}),
-      }
-    : {};
+  const cacheTransactionInfoById = initialAccount?.tronResources?.cacheTransactionInfoById || {};
   const operationsPageSize = Math.min(
-    1000,
-    getOperationsPageSize(initialAccount && initialAccount.id, syncConfig),
+    MAX_OPERATIONS_PAGE_SIZE,
+    getOperationsPageSize(initialAccount?.id, syncConfig),
   );
   // FIXME: this is not optional especially that we might already have initialAccount
   // use minimalOperationsBuilderSync to reconciliate and KEEP REF
@@ -86,68 +120,36 @@ export const getAccountShape: GetAccountShape<TronAccount> = async (
     parentTxs.map(tx => txInfoToOperation(accountId, address, tx)),
   );
 
-  const trc10Tokens = get(acc, "assetV2", []).reduce(
-    (accumulator: TronToken[], { key, value }: { key: string; value: number }) => {
-      const tokenInfo = findTokenById(`tron/trc10/${key}`);
-      if (tokenInfo) {
-        accumulator.push({
-          key,
-          type: "trc10",
-          tokenId: tokenInfo.id,
-          balance: value.toString(),
-        });
-      }
-      return accumulator;
-    },
-    [],
-  );
-
-  const trc20Tokens = get(acc, "trc20", []).reduce(
-    (accumulator: TronToken[], trc20: Record<string, string>) => {
-      const [[contractAddress, balance]] = Object.entries(trc20);
-      const tokenInfo = findTokenByAddressInCurrency(contractAddress, currency.id);
-      if (tokenInfo) {
-        accumulator.push({
-          key: contractAddress,
-          type: "trc20",
-          tokenId: tokenInfo.id,
-          balance,
-        });
-      }
-      return accumulator;
-    },
-    [],
-  );
+  const trc10Tokens = await getTrc10Tokens(acc);
+  const trc20Tokens = await getTrc20Tokens(acc, currency.id);
 
   const { blacklistedTokenIds = [] } = syncConfig;
 
-  const subAccounts: TokenAccount[] = compact(
-    trc10Tokens.concat(trc20Tokens).map(({ key, tokenId, balance }: TronToken) => {
-      const { blacklistedTokenIds = [] } = syncConfig;
-      const token = findTokenById(tokenId);
-      if (!token || blacklistedTokenIds.includes(tokenId)) return;
-      const id = encodeTokenAccountId(accountId, token);
-      const tokenTxs = txs.filter(tx => tx.tokenId === key);
-      const operations = compact(tokenTxs.map(tx => txInfoToOperation(id, address, tx)));
-      const maybeExistingSubAccount = initialAccount?.subAccounts?.find(a => a.id === id);
-      const bnBalance = new BigNumber(balance);
-      const sub: TokenAccount = {
-        type: "TokenAccount",
-        id,
-        parentId: accountId,
-        token,
-        balance: bnBalance,
-        spendableBalance: bnBalance,
-        operationsCount: operations.length,
-        operations,
-        pendingOperations: maybeExistingSubAccount ? maybeExistingSubAccount.pendingOperations : [],
-        creationDate: operations.length > 0 ? operations[operations.length - 1].date : new Date(),
-        swapHistory: maybeExistingSubAccount ? maybeExistingSubAccount.swapHistory : [],
-        balanceHistoryCache: emptyHistoryCache, // calculated in the jsHelpers
-      };
-      return sub;
-    }),
-  );
+  const subAccounts: TokenAccount[] = [];
+  for (const { key, tokenId, balance } of trc10Tokens.concat(trc20Tokens)) {
+    const token = await getCryptoAssetsStore().findTokenById(tokenId);
+    if (!token || blacklistedTokenIds.includes(tokenId)) continue;
+    const id = encodeTokenAccountId(accountId, token);
+    const tokenTxs = txs.filter(tx => tx.tokenId === key);
+    const operations = compact(tokenTxs.map(tx => txInfoToOperation(id, address, tx)));
+    const maybeExistingSubAccount = initialAccount?.subAccounts?.find(a => a.id === id);
+    const bnBalance = new BigNumber(balance);
+    const sub: TokenAccount = {
+      type: "TokenAccount",
+      id,
+      parentId: accountId,
+      token,
+      balance: bnBalance,
+      spendableBalance: bnBalance,
+      operationsCount: operations.length,
+      operations,
+      pendingOperations: maybeExistingSubAccount ? maybeExistingSubAccount.pendingOperations : [],
+      creationDate: operations.length > 0 ? operations[operations.length - 1].date : new Date(),
+      swapHistory: maybeExistingSubAccount ? maybeExistingSubAccount.swapHistory : [],
+      balanceHistoryCache: emptyHistoryCache, // calculated in the jsHelpers
+    };
+    subAccounts.push(sub);
+  }
 
   // Filter blacklisted tokens from the initial account's subAccounts
   // Could be use to filter out tokens that got their CAL id changed
@@ -231,19 +233,12 @@ export const postSync = (initial: TronAccount, parent: TronAccount): TronAccount
 const mergeSubAccounts = (subAccounts1: TokenAccount[], subAccounts2: TokenAccount[]) => {
   const existingIds = new Set(subAccounts1.map(subAccount => subAccount.id));
   const filteredSubAccounts2: TokenAccount[] = subAccounts2
-    .map(subAccount => {
-      if (existingIds.has(subAccount.id)) {
-        return null;
-      } else {
-        // Set balance and spendableBalance to 0 has if they are not here it means balance is 0
-        return {
-          ...subAccount,
-          balance: new BigNumber(0),
-          spendableBalance: new BigNumber(0),
-        };
-      }
-    })
-    .filter((elt): elt is NonNullable<typeof elt> => elt !== null);
+    .filter(subAccount => !existingIds.has(subAccount.id))
+    .map(subAccount => ({
+      ...subAccount,
+      balance: new BigNumber(0),
+      spendableBalance: new BigNumber(0),
+    }));
 
   return subAccounts1.concat(filteredSubAccounts2);
 };

package/src/test/bot-specs.ts

@@ -2,7 +2,7 @@ import { BigNumber } from "bignumber.js";
 import invariant from "invariant";
 import expect from "expect";
 import type { Transaction } from "../types";
-import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/index";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
 import { parseCurrencyUnit } from "@ledgerhq/coin-framework/currencies";
 import { botTest, pickSiblings } from "@ledgerhq/coin-framework/bot/specs";
 import type { AppSpec, TransactionDestinationTestInput } from "@ledgerhq/coin-framework/bot/types";