@ledgerhq/coin-tron 5.18.0 → 5.19.0

package/src/api/index.ts

@@ -1,18 +1,21 @@
+import { rejectBalanceOptions } from "@ledgerhq/coin-module-framework/api/getBalance/rejectBalanceOptions";
 import {
   AlpacaApi,
+  Balance,
+  CraftedTransaction,
   Cursor,
-  ListOperationsOptions,
-  Page,
-  Validator,
   FeeEstimation,
+  ListOperationsOptions,
   Operation,
+  Page,
   Reward,
   Stake,
   TransactionIntent,
-  CraftedTransaction,
   TransactionValidation,
-  Balance,
+  Validator,
+  BalanceOptions,
 } from "@ledgerhq/coin-module-framework/api/index";
+import { craftTransactionData } from "@ledgerhq/coin-module-framework/logic/craftTransactionData";
 import coinConfig, { type TronConfig } from "../config";
 import {
   broadcast,
@@ -22,13 +25,15 @@ import {
   getBalance,
   getBlock,
   getBlockInfo,
-  listOperations as listOperationsLogic,
   lastBlock,
+  listOperations as listOperationsLogic,
   validateAddress,
 } from "../logic";
 import { defaultFetchParams, getBlock as getBlockNetwork } from "../network";
 import type { TronMemo } from "../types";
 
+const MAX_TRONGRID_LIMIT = 200;
+
 export function createApi(config: TronConfig): AlpacaApi<TronMemo> {
   coinConfig.setCoinConfig(() => ({ ...config, status: { type: "active" } }));
 
@@ -45,7 +50,8 @@ export function createApi(config: TronConfig): AlpacaApi<TronMemo> {
       throw new Error("craftRawTransaction is not supported");
     },
     estimateFees: estimate,
-    getBalance,
+    getBalance: (address: string, options?: BalanceOptions) =>
+      rejectBalanceOptions(() => getBalance(address), options),
     lastBlock,
     listOperations,
     getBlock,
@@ -70,6 +76,7 @@ export function createApi(config: TronConfig): AlpacaApi<TronMemo> {
       throw new Error("getNextSequence is not supported");
     },
     validateAddress,
+    craftTransactionData,
   };
 }
 
@@ -82,7 +89,10 @@ async function listOperations(
   address: string,
   { minHeight, order, cursor, limit }: ListOperationsOptions,
 ): Promise<Page<Operation>> {
-  const effectiveLimit = limit ?? 200;
+  if (limit !== undefined && limit > MAX_TRONGRID_LIMIT) {
+    throw new Error(`limit must be <= ${MAX_TRONGRID_LIMIT} for Tron (TronGrid API restriction)`);
+  }
+  const effectiveLimit = limit ?? MAX_TRONGRID_LIMIT;
   const effectiveOrder = order ?? "asc";
 
   let minTimestamp = defaultFetchParams.minTimestamp;

package/src/bridge/index.ts

@@ -16,7 +16,6 @@ import broadcast from "./broadcast";
 import createTransaction from "./createTransaction";
 import estimateMaxSpendable from "./estimateMaxSpendable";
 import getTransactionStatus from "./getTransactionStatus";
-import { hydrate, preload } from "./preload";
 import { prepareTransaction } from "./prepareTransaction";
 import {
   assignFromAccountRaw,
@@ -37,8 +36,8 @@ function buildCurrencyBridge(signerContext: SignerContext<TronSigner>): Currency
   });
 
   return {
-    preload,
-    hydrate,
+    preload: () => Promise.resolve({}),
+    hydrate: () => undefined,
     scanAccounts,
   };
 }

package/src/bridge/prepareTransaction.test.ts

@@ -0,0 +1,118 @@
+import BigNumber from "bignumber.js";
+import { accountNamesCache, getTronAccountNetwork } from "../network";
+import { NetworkInfo, Transaction, TronAccount } from "../types";
+import { prepareTransaction } from "./prepareTransaction";
+
+jest.mock("../network", () => ({
+  getTronAccountNetwork: jest.fn(),
+  accountNamesCache: jest.fn(),
+}));
+
+const mockGetTronAccountNetwork = jest.mocked(getTronAccountNetwork);
+const mockAccountNamesCache = jest.mocked(accountNamesCache);
+
+const baseNetworkInfo: NetworkInfo = {
+  family: "tron",
+  freeNetUsed: new BigNumber(1),
+  freeNetLimit: new BigNumber(2),
+  netUsed: new BigNumber(3),
+  netLimit: new BigNumber(4),
+  energyUsed: new BigNumber(5),
+  energyLimit: new BigNumber(6),
+};
+
+const createTransaction = (overrides: Partial<Transaction> = {}): Transaction => ({
+  family: "tron",
+  mode: "send",
+  resource: "BANDWIDTH",
+  networkInfo: undefined,
+  duration: null,
+  votes: [],
+  amount: new BigNumber(0),
+  recipient: "mock-recipient",
+  ...overrides,
+});
+
+const createAccount = (overrides: Partial<TronAccount> = {}): TronAccount =>
+  ({
+    freshAddress: "TMockFreshAddress",
+    ...overrides,
+  }) as TronAccount;
+
+describe("prepareTransaction", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should return the same transaction when networkInfo is already set", async () => {
+    const account = createAccount();
+    const transaction = createTransaction({ networkInfo: baseNetworkInfo });
+
+    const result = await prepareTransaction(account, transaction);
+
+    expect(result).toBe(transaction);
+    expect(mockGetTronAccountNetwork).not.toHaveBeenCalled();
+  });
+
+  it("should fetch network info when networkInfo is missing", async () => {
+    const account = createAccount({ freshAddress: "TAddr123" });
+    const transaction = createTransaction({ networkInfo: undefined });
+    mockGetTronAccountNetwork.mockResolvedValue(baseNetworkInfo);
+
+    const result = await prepareTransaction(account, transaction);
+
+    expect(mockGetTronAccountNetwork).toHaveBeenCalledTimes(1);
+    expect(mockGetTronAccountNetwork).toHaveBeenCalledWith("TAddr123");
+    expect(result).not.toBe(transaction);
+    expect(result.networkInfo).toEqual(baseNetworkInfo);
+  });
+
+  it("should enrich vote names using accountNamesCache when votes are present", async () => {
+    const account = createAccount();
+    const voteAddress = "TVoteAddr";
+    const transaction = createTransaction({
+      networkInfo: baseNetworkInfo,
+      votes: [{ address: voteAddress, voteCount: 100, name: undefined }],
+    });
+    mockAccountNamesCache.mockResolvedValue("SR name");
+
+    const result = await prepareTransaction(account, transaction);
+
+    expect(mockAccountNamesCache).toHaveBeenCalledWith(voteAddress);
+    expect(result.votes).toEqual([
+      { address: voteAddress, voteCount: 100, name: "SR name" },
+    ]);
+  });
+
+  it("should enrich multiple votes in parallel", async () => {
+    const account = createAccount();
+    const transaction = createTransaction({
+      networkInfo: baseNetworkInfo,
+      votes: [
+        { address: "TA", voteCount: 1, name: undefined },
+        { address: "TB", voteCount: 2, name: undefined },
+      ],
+    });
+    mockAccountNamesCache.mockImplementation(async addr =>
+      addr === "TA" ? "Name A" : "Name B",
+    );
+
+    await prepareTransaction(account, transaction);
+
+    expect(mockAccountNamesCache).toHaveBeenCalledTimes(2);
+    expect(mockAccountNamesCache).toHaveBeenCalledWith("TA");
+    expect(mockAccountNamesCache).toHaveBeenCalledWith("TB");
+  });
+
+  it("should not call accountNamesCache when there are no votes", async () => {
+    const account = createAccount();
+    const transaction = createTransaction({
+      networkInfo: baseNetworkInfo,
+      votes: [],
+    });
+
+    await prepareTransaction(account, transaction);
+
+    expect(mockAccountNamesCache).not.toHaveBeenCalled();
+  });
+});

package/src/bridge/prepareTransaction.ts

@@ -1,5 +1,5 @@
 import { AccountBridge } from "@ledgerhq/types-live";
-import { getTronAccountNetwork } from "../network";
+import { accountNamesCache, getTronAccountNetwork } from "../network";
 import { Transaction, TronAccount } from "../types";
 
 export const prepareTransaction: AccountBridge<
@@ -8,5 +8,15 @@ export const prepareTransaction: AccountBridge<
 >["prepareTransaction"] = async (account, transaction) => {
   const networkInfo =
     transaction.networkInfo || (await getTronAccountNetwork(account.freshAddress));
+
+  if (transaction.votes.length) {
+    transaction.votes = await Promise.all(
+      transaction.votes.map(async vote => ({
+        ...vote,
+        name: await accountNamesCache(vote.address),
+      })),
+    );
+  }
+
   return transaction.networkInfo === networkInfo ? transaction : { ...transaction, networkInfo };
 };

package/src/bridge/utils.ts

@@ -1,8 +1,9 @@
 import { encodeOperationId } from "@ledgerhq/ledger-wallet-framework/operation";
+import get from "lodash/get";
 import type { Account, OperationType } from "@ledgerhq/types-live";
 import { BigNumber } from "bignumber.js";
 import { type AccountInfo, getTronResources as getTronResourcesLogic } from "../logic/utils";
-import { getTronAccountNetwork, getUnwithdrawnReward } from "../network";
+import { accountNamesCache, getTronAccountNetwork, getUnwithdrawnReward } from "../network";
 import { encode58Check } from "../network/format";
 import type {
   BandwidthInfo,
@@ -251,8 +252,18 @@ export async function getTronResources(
   };
   const lastVotedDate = txs ? getLastVotedDate(txs) : undefined;
 
+  const rawVotes = get(acc, "votes", []).sort((a, b) => b.vote_count - a.vote_count);
+  const votes = await Promise.all(
+    rawVotes.map(async v => ({
+      name: await accountNamesCache(v.vote_address),
+      address: v.vote_address,
+      voteCount: v.vote_count,
+    })),
+  );
+
   return {
     ...getTronResourcesLogic(acc),
+    votes,
     energy,
     bandwidth,
     unwithdrawnReward,

package/src/logic/listOperations.ts

@@ -10,6 +10,7 @@ import {
   dropTxsBeforeCursor,
   parseCursor,
 } from "./cursor";
+import { TronEmptyPage } from "../types/errors";
 
 // Pagination uses a SUI-style cursor approach to handle two separate endpoints
 // (native transactions and TRC20 transactions) while maintaining chronological order.
@@ -64,6 +65,15 @@ export async function listOperations(
     },
   );
 
+  // TronGrid occasionally returns an empty page for a valid cursor (transient API failure).
+  // A cursor is only issued when TronGrid indicated hasNextPage=true, so 0 results here
+  // is never a legitimate end-of-stream — throw so the client can retry with the same cursor.
+  if (parsedCursor && nativeTxs.txs.length === 0 && trc20Txs.txs.length === 0) {
+    throw new TronEmptyPage(
+      `TronGrid returned empty page for cursor ${cursor} — transient failure, retry required`,
+    );
+  }
+
   // Merge and dedupe: some transactions appear in both native and TRC20 results
   const mergedTxs = uniqBy([...nativeTxs.txs, ...trc20Txs.txs], tx => tx.txID);
   const sortedTxs = [...mergedTxs].sort(compareTxsByTimestamp(order));

package/src/logic/listOperations.unit.test.ts

@@ -3,6 +3,7 @@ import { fetchTronAccountTxsPage, getBlock } from "../network";
 import { fromTrongridTxInfoToOperation } from "../network/trongrid/trongrid-adapters";
 import { TrongridTxInfo } from "../types";
 import { listOperations, ListOperationsOptions } from "./listOperations";
+import { TronEmptyPage } from "../types/errors";
 
 jest.mock("../network", () => ({
   fetchTronAccountTxsPage: jest.fn(),
@@ -67,7 +68,7 @@ describe("listOperations", () => {
     expect(result.next).toBeUndefined();
   });
 
-  it("should handle empty transactions", async () => {
+  it("should handle empty transactions on first page (no cursor)", async () => {
     (fetchTronAccountTxsPage as jest.Mock).mockResolvedValue({
       nativeTxs: { txs: [], hasNextPage: false },
       trc20Txs: { txs: [], hasNextPage: false },
@@ -79,6 +80,21 @@ describe("listOperations", () => {
     expect(result.next).toBeUndefined();
   });
 
+  it("should throw TronEmptyPage when cursor is provided but TronGrid returns empty page", async () => {
+    // TronGrid occasionally returns 0 results for a valid cursor (transient failure).
+    // A cursor is only issued when hasNextPage=true, so this is never a legitimate end-of-stream.
+    (fetchTronAccountTxsPage as jest.Mock).mockResolvedValue({
+      nativeTxs: { txs: [], hasNextPage: false },
+      trc20Txs: { txs: [], hasNextPage: false },
+    });
+
+    const cursor = `${new Date("2023-01-01T01:00:00Z").getTime()}:tx1`;
+
+    await expect(listOperations(mockAddress, { ...defaultOptions, cursor })).rejects.toThrow(
+      TronEmptyPage,
+    );
+  });
+
   it("should return cursor when hasNextPage is true", async () => {
     const mockTxs: Partial<TrongridTxInfo>[] = [
       {
@@ -434,13 +450,26 @@ describe("listOperations", () => {
   });
 
   it("should pass cursor timestamp as minTimestamp for asc order pagination", async () => {
+    const cursorTimestamp = new Date("2023-01-01T02:00:00Z").getTime();
+    const cursor = `${cursorTimestamp}:tx2`;
     (fetchTronAccountTxsPage as jest.Mock).mockResolvedValue({
-      nativeTxs: { txs: [], hasNextPage: false },
+      nativeTxs: {
+        txs: [
+          {
+            txID: "tx3",
+            value: new BigNumber(30),
+            date: new Date("2023-01-01T03:00:00Z"),
+            blockHeight: 300,
+          },
+        ],
+        hasNextPage: false,
+      },
       trc20Txs: { txs: [], hasNextPage: false },
     });
-
-    const cursorTimestamp = new Date("2023-01-01T02:00:00Z").getTime();
-    const cursor = `${cursorTimestamp}:tx2`;
+    (fromTrongridTxInfoToOperation as jest.Mock).mockImplementation(tx => ({
+      tx: { hash: tx.txID },
+      value: BigInt(tx.value.toString()),
+    }));
     const minTimestamp = 1000;
 
     await listOperations(mockAddress, {

package/src/logic/utils.test.ts

@@ -127,7 +127,6 @@ describe("getTronResources", () => {
         legacyFrozen: { bandwidth: undefined, energy: undefined },
         tronPower: 0,
         unFrozen: { bandwidth: [], energy: [] },
-        votes: [],
       },
     },
     {
@@ -142,7 +141,6 @@ describe("getTronResources", () => {
         legacyFrozen: { bandwidth: undefined, energy: undefined },
         tronPower: 10,
         unFrozen: { bandwidth: [], energy: [] },
-        votes: [],
       },
     },
     {
@@ -159,7 +157,6 @@ describe("getTronResources", () => {
         legacyFrozen: { bandwidth: undefined, energy: undefined },
         tronPower: 11,
         unFrozen: { bandwidth: [], energy: [] },
-        votes: [],
       },
     },
     {
@@ -178,7 +175,6 @@ describe("getTronResources", () => {
         legacyFrozen: { bandwidth: undefined, energy: undefined },
         tronPower: 0,
         unFrozen: { bandwidth: [], energy: [] },
-        votes: [],
       },
     },
     {
@@ -198,7 +194,6 @@ describe("getTronResources", () => {
         legacyFrozen: { bandwidth: undefined, energy: undefined },
         tronPower: 12,
         unFrozen: { bandwidth: [], energy: [] },
-        votes: [],
       },
     },
     {
@@ -218,7 +213,6 @@ describe("getTronResources", () => {
         legacyFrozen: { bandwidth: undefined, energy: undefined },
         tronPower: 0,
         unFrozen: { bandwidth: [], energy: [] },
-        votes: [],
       },
     },
     {
@@ -237,7 +231,6 @@ describe("getTronResources", () => {
         legacyFrozen: { bandwidth: undefined, energy: undefined },
         tronPower: 14,
         unFrozen: { bandwidth: [], energy: [] },
-        votes: [],
       },
     },
     {
@@ -252,7 +245,6 @@ describe("getTronResources", () => {
         legacyFrozen: { bandwidth: undefined, energy: undefined },
         tronPower: 0,
         unFrozen: { bandwidth: [], energy: [] },
-        votes: [],
       },
     },
     {
@@ -278,7 +270,6 @@ describe("getTronResources", () => {
         },
         tronPower: 15,
         unFrozen: { bandwidth: [], energy: [] },
-        votes: [],
       },
     },
     {
@@ -304,7 +295,6 @@ describe("getTronResources", () => {
         },
         tronPower: 16,
         unFrozen: { bandwidth: [], energy: [] },
-        votes: [],
       },
     },
     {
@@ -342,32 +332,6 @@ describe("getTronResources", () => {
             },
           ],
         },
-        votes: [],
-      },
-    },
-    {
-      name: "Votes",
-      account: {
-        votes: [
-          {
-            vote_address: "VOTE ADDRESS",
-            vote_count: 23,
-          },
-        ],
-      },
-      expected: {
-        delegatedFrozen: { bandwidth: undefined, energy: undefined },
-        frozen: { bandwidth: undefined, energy: undefined },
-        lastWithdrawnRewardDate: undefined,
-        legacyFrozen: { bandwidth: undefined, energy: undefined },
-        tronPower: 0,
-        unFrozen: { bandwidth: [], energy: [] },
-        votes: [
-          {
-            address: "VOTE ADDRESS",
-            voteCount: 23,
-          },
-        ],
       },
     },
     {
@@ -382,7 +346,6 @@ describe("getTronResources", () => {
         legacyFrozen: { bandwidth: undefined, energy: undefined },
         tronPower: 0,
         unFrozen: { bandwidth: [], energy: [] },
-        votes: [],
       },
     },
   ];

package/src/logic/utils.ts

@@ -256,7 +256,12 @@ export function getTronResources(
   acc: AccountInfo,
 ): Omit<
   TronResources,
-  "energy" | "bandwidth" | "unwithdrawnReward" | "lastVotedDate" | "cacheTransactionInfoById"
+  | "energy"
+  | "bandwidth"
+  | "unwithdrawnReward"
+  | "lastVotedDate"
+  | "cacheTransactionInfoById"
+  | "votes"
 > {
   const delegatedFrozenBandwidth = get(acc, "delegated_frozenV2_balance_for_bandwidth", undefined);
   const delegatedFrozenEnergy = get(
@@ -361,11 +366,6 @@ export function getTronResources(
     .integerValue(BigNumber.ROUND_FLOOR)
     .toNumber();
 
-  const votes = get(acc, "votes", []).map((v: any) => ({
-    address: v.vote_address,
-    voteCount: v.vote_count,
-  }));
-
   const lastWithdrawnRewardDate = acc.latest_withdraw_time
     ? new Date(acc.latest_withdraw_time)
     : undefined;
@@ -375,7 +375,6 @@ export function getTronResources(
     unFrozen,
     delegatedFrozen,
     legacyFrozen,
-    votes,
     tronPower,
     lastWithdrawnRewardDate,
   };