@ledgerhq/coin-hedera 1.15.0 → 1.16.0-nightly.20251210114107

package/src/network/api.test.ts

@@ -72,7 +72,6 @@ describe("getAccountTransactions", () => {
       fetchAllPages: true,
     });
 
-    expect(result.transactions).toHaveLength(3);
     expect(result.transactions.map(tx => tx.consensus_timestamp)).toEqual(["1", "3", "4"]);
     expect(result.nextCursor).toBeNull();
     expect(mockedNetwork).toHaveBeenCalledTimes(5);
@@ -118,7 +117,6 @@ describe("getAccountTransactions", () => {
       fetchAllPages: false,
     });
 
-    expect(result.transactions).toHaveLength(2);
     expect(result.transactions.map(tx => tx.consensus_timestamp)).toEqual(["1", "3"]);
     expect(result.nextCursor).toBe("3");
     expect(mockedNetwork).toHaveBeenCalledTimes(3);
@@ -267,6 +265,7 @@ describe("findTransactionByContractCall", () => {
     const mockedResults: HederaMirrorTransaction = {
       transfers: [],
       token_transfers: [],
+      staking_reward_transfers: [],
       charged_tx_fee: 100,
       transaction_id: "xxxxxxxxxxxxxx",
       transaction_hash: "xxxxxxxxxxxxx",
@@ -300,6 +299,7 @@ describe("findTransactionByContractCall", () => {
           {
             transfers: [],
             token_transfers: [],
+            staking_reward_transfers: [],
             charged_tx_fee: 100,
             transaction_hash: "xxxxxxxxxxxxx",
             consensus_timestamp: "xxxxxxxxxxxxx",
@@ -310,6 +310,7 @@ describe("findTransactionByContractCall", () => {
           {
             transfers: [],
             token_transfers: [],
+            staking_reward_transfers: [],
             charged_tx_fee: 100,
             transaction_hash: "xxxxxxxxxxxxx",
             consensus_timestamp: "xxxxxxxxxxxxx",
@@ -317,7 +318,7 @@ describe("findTransactionByContractCall", () => {
             entity_id: "0.0.1111",
             name: "CONTRACTCALL",
           },
-        ],
+        ] satisfies Partial<HederaMirrorTransaction>[],
       }),
     );
 
@@ -450,7 +451,6 @@ describe("getTransactionsByTimestampRange", () => {
       "2000.000000000",
     );
 
-    expect(result).toHaveLength(2);
     expect(result.map(tx => tx.consensus_timestamp)).toEqual(["1500.123456789", "1750.987654321"]);
     expect(mockedNetwork).toHaveBeenCalledTimes(1);
   });
@@ -481,7 +481,6 @@ describe("getTransactionsByTimestampRange", () => {
       "2000.000000000",
     );
 
-    expect(result).toHaveLength(3);
     expect(result.map(tx => tx.consensus_timestamp)).toEqual([
       "1100.000000000",
       "1200.000000000",
@@ -516,8 +515,61 @@ describe("getTransactionsByTimestampRange", () => {
       "2000.000000000",
     );
 
-    expect(result).toHaveLength(2);
     expect(result.map(tx => tx.consensus_timestamp)).toEqual(["1100.000000000", "1300.000000000"]);
     expect(mockedNetwork).toHaveBeenCalledTimes(3);
   });
 });
+
+describe("getNodes", () => {
+  beforeEach(() => {
+    jest.resetAllMocks();
+  });
+
+  it("should return all nodes if only one page is needed", async () => {
+    mockedNetwork.mockResolvedValueOnce(
+      getMockResponse({
+        nodes: [
+          { node_id: 0, node_account_id: "0.0.3" },
+          { node_id: 1, node_account_id: "0.0.4" },
+        ],
+        links: { next: null },
+      }),
+    );
+
+    const result = await apiClient.getNodes();
+    const requestUrl = mockedNetwork.mock.calls[0][0].url;
+
+    expect(result.map(n => n.node_id)).toEqual([0, 1]);
+    expect(requestUrl).toContain("/api/v1/network/nodes");
+    expect(requestUrl).toContain("limit=100");
+    expect(requestUrl).toContain("order=desc");
+    expect(mockedNetwork).toHaveBeenCalledTimes(1);
+  });
+
+  it("should keep fetching if links.next is present and new nodes are returned", async () => {
+    mockedNetwork
+      .mockResolvedValueOnce(
+        getMockResponse({
+          nodes: [{ node_id: 0, node_account_id: "0.0.3" }],
+          links: { next: "/next-1" },
+        }),
+      )
+      .mockResolvedValueOnce(
+        getMockResponse({
+          nodes: [{ node_id: 1, node_account_id: "0.0.4" }],
+          links: { next: "/next-2" },
+        }),
+      )
+      .mockResolvedValueOnce(
+        getMockResponse({
+          nodes: [{ node_id: 2, node_account_id: "0.0.5" }],
+          links: { next: null },
+        }),
+      );
+
+    const result = await apiClient.getNodes();
+
+    expect(result.map(n => n.node_id)).toEqual([0, 1, 2]);
+    expect(mockedNetwork).toHaveBeenCalledTimes(3);
+  });
+});

package/src/network/api.ts

@@ -16,6 +16,8 @@ import type {
   HederaMirrorContractCallResult,
   HederaMirrorContractCallBalance,
   HederaMirrorContractCallEstimate,
+  HederaMirrorNode,
+  HederaMirrorNodesResponse,
 } from "../types";
 
 const API_URL = getEnv("API_HEDERA_MIRROR");
@@ -267,6 +269,28 @@ async function getTransactionsByTimestampRange(
   return transactions;
 }
 
+async function getNodes(): Promise<HederaMirrorNode[]> {
+  const nodes: HederaMirrorNode[] = [];
+  const params = new URLSearchParams({
+    order: "desc",
+    limit: "100",
+  });
+
+  let nextPath: string | null = `/api/v1/network/nodes?${params.toString()}`;
+
+  while (nextPath) {
+    const res: LiveNetworkResponse<HederaMirrorNodesResponse> = await network({
+      method: "GET",
+      url: `${API_URL}${nextPath}`,
+    });
+    const newNodes = res.data.nodes;
+    nodes.push(...newNodes);
+    nextPath = res.data.links.next;
+  }
+
+  return nodes;
+}
+
 export const apiClient = {
   getAccountsForPublicKey,
   getAccount,
@@ -279,4 +303,5 @@ export const apiClient = {
   getERC20Balance,
   estimateContractCallGas,
   getTransactionsByTimestampRange,
+  getNodes,
 };

package/src/network/thirdweb.test.ts

@@ -84,7 +84,7 @@ describe("fetchERC20Transactions", () => {
     };
     const result = await thirdwebClient.fetchERC20Transactions(mockedERC20TokenAddress1, params);
 
-    expect(result).toHaveLength(0);
+    expect(result).toEqual([]);
     expect(mockedNetwork).toHaveBeenCalledTimes(1);
   });
 
@@ -139,7 +139,7 @@ describe("getERC20TransactionsForAccount", () => {
       since: null,
     });
 
-    expect(result).toHaveLength(0);
+    expect(result).toEqual([]);
   });
 
   it("should return exactly 2 transactions (out & in)", async () => {

package/src/network/utils.test.ts

@@ -207,8 +207,7 @@ describe("network utils", () => {
         erc20Token.contractAddress,
       );
 
-      expect(res).toHaveLength(mockedSupportedTokenIds.length);
-      expect(res).toMatchObject(mockedResponse);
+      expect(res).toEqual(mockedResponse);
     });
 
     it("returns empty array when there are no supported ERC20 tokens", async () => {
@@ -265,8 +264,7 @@ describe("network utils", () => {
 
       const result = await getERC20Operations([mockThirdwebTransaction]);
 
-      expect(result).toHaveLength(1);
-      expect(result).toMatchObject([
+      expect(result).toEqual([
         {
           thirdwebTransaction: mockThirdwebTransaction,
           mirrorTransaction: mockMirrorTransaction,
@@ -299,7 +297,7 @@ describe("network utils", () => {
 
       const result = await getERC20Operations(mockThirdwebTransactions);
 
-      expect(result).toHaveLength(0);
+      expect(result).toEqual([]);
       expect(apiClient.getContractCallResult).not.toHaveBeenCalled();
       expect(apiClient.findTransactionByContractCall).not.toHaveBeenCalled();
     });
@@ -328,7 +326,7 @@ describe("network utils", () => {
 
       const result = await getERC20Operations([mockThirdwebTransactions]);
 
-      expect(result).toHaveLength(0);
+      expect(result).toEqual([]);
     });
   });
 

package/src/preload-data.ts

@@ -0,0 +1,38 @@
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { BehaviorSubject, Observable } from "rxjs";
+import type { HederaPreloadData } from "./types";
+
+const initialData: HederaPreloadData = {
+  validators: [],
+};
+
+const dataByCurrency = new Map<string, HederaPreloadData>([["hedera", initialData]]);
+
+const dataUpdatesByCurrency = new Map([
+  ["hedera", new BehaviorSubject<HederaPreloadData>(initialData)],
+]);
+
+export function setHederaPreloadData(data: HederaPreloadData, currency: CryptoCurrency): void {
+  dataByCurrency.set(currency.id, data ?? initialData);
+  const subject = dataUpdatesByCurrency.get(currency.id);
+  if (subject === undefined) {
+    throw new Error(`unsupported currency ${currency.id}`);
+  }
+  subject.next(data);
+}
+
+export function getHederaPreloadData(currency: CryptoCurrency): Observable<HederaPreloadData> {
+  const subject = dataUpdatesByCurrency.get(currency.id);
+  if (subject === undefined) {
+    throw new Error(`unsupported currency ${currency.id}`);
+  }
+  return subject.asObservable();
+}
+
+export function getCurrentHederaPreloadData(currency: CryptoCurrency): HederaPreloadData {
+  const data = dataByCurrency.get(currency.id);
+  if (data === undefined) {
+    throw new Error(`unsupported currency ${currency.id}`);
+  }
+  return data;
+}

package/src/preload.test.ts

@@ -0,0 +1,64 @@
+import BigNumber from "bignumber.js";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
+import { hydrate } from "./preload";
+import { setHederaPreloadData } from "./preload-data";
+
+jest.mock("./preload-data", () => ({
+  setHederaPreloadData: jest.fn(),
+}));
+
+describe("hydrate", () => {
+  const currency = getCryptoCurrencyById("hedera");
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test.each([undefined, null, {}, []])(
+    "should hydrate empty validators list if data is corrupted (%p value)",
+    value => {
+      hydrate(value, currency);
+      expect(setHederaPreloadData).toHaveBeenCalledWith({ validators: [] }, currency);
+    },
+  );
+
+  it("should hydrate valid validators list", () => {
+    hydrate(
+      {
+        validators: [
+          {
+            nodeId: 1,
+            address: "0.0.1",
+            addressChecksum: "abcde",
+            name: "Ledger",
+            minStake: "1",
+            maxStake: "10",
+            activeStake: "5",
+            activeStakePercentage: "50",
+            overstaked: false,
+          },
+        ],
+      },
+      currency,
+    );
+
+    expect(setHederaPreloadData).toHaveBeenCalledWith(
+      {
+        validators: [
+          {
+            nodeId: 1,
+            address: "0.0.1",
+            addressChecksum: "abcde",
+            name: "Ledger",
+            minStake: new BigNumber(1),
+            maxStake: new BigNumber(10),
+            activeStake: new BigNumber(5),
+            activeStakePercentage: new BigNumber(50),
+            overstaked: false,
+          },
+        ],
+      },
+      currency,
+    );
+  });
+});

package/src/preload.ts

@@ -0,0 +1,80 @@
+import BigNumber from "bignumber.js";
+import { log } from "@ledgerhq/logs";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { extractCompanyFromNodeDescription, getChecksum, sortValidators } from "./logic/utils";
+import { apiClient } from "./network/api";
+import { setHederaPreloadData } from "./preload-data";
+import type { HederaPreloadData, HederaValidator, HederaValidatorRaw } from "./types";
+
+export const getPreloadStrategy = () => ({
+  preloadMaxAge: 15 * 60 * 1000, // 15 minutes
+});
+
+export async function preload(currency: CryptoCurrency): Promise<HederaPreloadData> {
+  log("hedera/preload", "preloading hedera data...");
+  const nodes = await apiClient.getNodes();
+
+  const validators: HederaValidator[] = nodes.map(mirrorNode => {
+    const minStake = new BigNumber(mirrorNode.min_stake);
+    const maxStake = new BigNumber(mirrorNode.max_stake);
+    const activeStake = new BigNumber(mirrorNode.stake_rewarded);
+    const activeStakePercentage = maxStake.gt(0)
+      ? activeStake.dividedBy(maxStake).multipliedBy(100).dp(0, BigNumber.ROUND_CEIL)
+      : new BigNumber(0);
+
+    return {
+      nodeId: mirrorNode.node_id,
+      address: mirrorNode.node_account_id,
+      addressChecksum: getChecksum(mirrorNode.node_account_id),
+      name: extractCompanyFromNodeDescription(mirrorNode.description),
+      minStake,
+      maxStake,
+      activeStake,
+      activeStakePercentage,
+      overstaked: activeStake.gte(maxStake),
+    };
+  });
+
+  const sortedValidators = sortValidators(validators);
+  const data: HederaPreloadData = {
+    validators: sortedValidators,
+  };
+
+  setHederaPreloadData(data, currency);
+
+  return data;
+}
+
+function mapRawValidatorToValidator(validatorRaw: HederaValidatorRaw): HederaValidator {
+  return {
+    nodeId: validatorRaw.nodeId,
+    address: validatorRaw.address,
+    addressChecksum: validatorRaw.addressChecksum,
+    name: validatorRaw.name,
+    minStake: new BigNumber(validatorRaw.minStake),
+    maxStake: new BigNumber(validatorRaw.maxStake),
+    activeStake: new BigNumber(validatorRaw.activeStake),
+    activeStakePercentage: new BigNumber(validatorRaw.activeStakePercentage),
+    overstaked: validatorRaw.overstaked,
+  };
+}
+
+function fromHydratePreloadData(data: unknown): HederaPreloadData {
+  let validators: HederaValidator[] = [];
+
+  if (data && typeof data === "object" && "validators" in data) {
+    if (Array.isArray(data.validators)) {
+      validators = data.validators.map(mapRawValidatorToValidator);
+    }
+  }
+
+  return {
+    validators,
+  };
+}
+
+export function hydrate(data: unknown, currency: CryptoCurrency): void {
+  const hydrated = fromHydratePreloadData(data);
+  log("hedera/preload", `hydrated ${hydrated.validators.length} hedera validators`);
+  setHederaPreloadData(hydrated, currency);
+}

package/src/test/fixtures/account.fixture.ts

@@ -5,9 +5,9 @@ import type {
   HederaResources,
   HederaResourcesRaw,
 } from "../../types";
+import type { TokenCurrency } from "@ledgerhq/types-cryptoassets";
 import type { TokenAccount } from "@ledgerhq/types-live";
 import { getMockedCurrency, getMockedHTSTokenCurrency } from "./currency.fixture";
-import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
 
 const defaultMockedCurrency = getMockedCurrency();
 const defaultMockedTokenCurrency = getMockedHTSTokenCurrency();
@@ -19,11 +19,13 @@ const defaultTokenBalance = new BigNumber(10);
 export const mockHederaResources: HederaResources = {
   maxAutomaticTokenAssociations: 0,
   isAutoTokenAssociationEnabled: false,
+  delegation: null,
 };
 
 export const mockHederaResourcesRaw: HederaResourcesRaw = {
   maxAutomaticTokenAssociations: 0,
   isAutoTokenAssociationEnabled: false,
+  delegation: null,
 };
 
 /**

package/src/transaction.ts

@@ -40,6 +40,27 @@ export function fromTransactionRaw(tr: TransactionRaw): Transaction {
     };
   }
 
+  if (
+    tr.mode === HEDERA_TRANSACTION_MODES.Delegate ||
+    tr.mode === HEDERA_TRANSACTION_MODES.Undelegate ||
+    tr.mode === HEDERA_TRANSACTION_MODES.Redelegate
+  ) {
+    return {
+      ...commonGeneric,
+      ...commonHedera,
+      mode: tr.mode,
+      properties: tr.properties,
+    };
+  }
+
+  if (tr.mode === HEDERA_TRANSACTION_MODES.ClaimRewards) {
+    return {
+      ...commonGeneric,
+      ...commonHedera,
+      mode: tr.mode,
+    };
+  }
+
   return {
     ...commonGeneric,
     ...commonHedera,
@@ -67,6 +88,27 @@ export function toTransactionRaw(t: Transaction): TransactionRaw {
     };
   }
 
+  if (
+    t.mode === HEDERA_TRANSACTION_MODES.Delegate ||
+    t.mode === HEDERA_TRANSACTION_MODES.Undelegate ||
+    t.mode === HEDERA_TRANSACTION_MODES.Redelegate
+  ) {
+    return {
+      ...commonGeneric,
+      ...commonHedera,
+      mode: t.mode,
+      properties: t.properties,
+    };
+  }
+
+  if (t.mode === HEDERA_TRANSACTION_MODES.ClaimRewards) {
+    return {
+      ...commonGeneric,
+      ...commonHedera,
+      mode: t.mode,
+    };
+  }
+
   return {
     ...commonGeneric,
     ...commonHedera,

package/src/types/alpaca.ts

@@ -7,4 +7,8 @@ export type HederaTxData =
   | {
       type: "erc20";
       gasLimit: bigint;
+    }
+  | {
+      type: "staking";
+      stakingNodeId: number | null | undefined;
     };

package/src/types/bridge.ts

@@ -9,7 +9,7 @@ import type {
   TransactionStatusCommon,
   TransactionStatusCommonRaw,
 } from "@ledgerhq/types-live";
-import { HEDERA_TRANSACTION_MODES } from "../constants";
+import { HEDERA_DELEGATION_STATUS, HEDERA_TRANSACTION_MODES } from "../constants";
 
 export type NetworkInfo = {
   family: "hedera";
@@ -37,6 +37,28 @@ export type Transaction = TransactionCommon & {
           token: TokenCurrency;
         };
       }
+    | {
+        mode: HEDERA_TRANSACTION_MODES.Delegate;
+        properties: {
+          stakingNodeId: number | null;
+        };
+      }
+    | {
+        mode: HEDERA_TRANSACTION_MODES.Undelegate;
+        properties: {
+          stakingNodeId: number | null;
+        };
+      }
+    | {
+        mode: HEDERA_TRANSACTION_MODES.Redelegate;
+        properties: {
+          stakingNodeId: number | null;
+        };
+      }
+    | {
+        mode: HEDERA_TRANSACTION_MODES.ClaimRewards;
+        properties?: never;
+      }
   );
 
 export type TransactionRaw = TransactionCommonRaw & {
@@ -57,25 +79,77 @@ export type TransactionRaw = TransactionCommonRaw & {
           token: TokenCurrency;
         };
       }
+    | {
+        mode: HEDERA_TRANSACTION_MODES.Delegate;
+        properties: {
+          stakingNodeId: number | null;
+        };
+      }
+    | {
+        mode: HEDERA_TRANSACTION_MODES.Undelegate;
+        properties: {
+          stakingNodeId: number | null;
+        };
+      }
+    | {
+        mode: HEDERA_TRANSACTION_MODES.Redelegate;
+        properties: {
+          stakingNodeId: number | null;
+        };
+      }
+    | {
+        mode: HEDERA_TRANSACTION_MODES.ClaimRewards;
+        properties?: never;
+      }
   );
 
+export type TransactionStatus = TransactionStatusCommon;
+
+export type TransactionStatusRaw = TransactionStatusCommonRaw;
+
 export type TransactionTokenAssociate = Extract<
   Transaction,
   { mode: HEDERA_TRANSACTION_MODES.TokenAssociate }
 >;
 
-export type TransactionStatus = TransactionStatusCommon;
+export type TransactionStaking = Extract<
+  Transaction,
+  {
+    mode:
+      | HEDERA_TRANSACTION_MODES.Delegate
+      | HEDERA_TRANSACTION_MODES.Undelegate
+      | HEDERA_TRANSACTION_MODES.Redelegate
+      | HEDERA_TRANSACTION_MODES.ClaimRewards;
+  }
+>;
 
-export type TransactionStatusRaw = TransactionStatusCommonRaw;
+export interface HederaDelegation {
+  nodeId: number;
+  delegated: BigNumber;
+  pendingReward: BigNumber;
+}
+
+export interface HederaEnrichedDelegation extends HederaDelegation {
+  status: HEDERA_DELEGATION_STATUS;
+  validator: HederaValidator;
+}
+
+interface HederaDelegationRaw {
+  nodeId: number;
+  delegated: string;
+  pendingReward: string;
+}
 
 export interface HederaResources {
   maxAutomaticTokenAssociations: number;
   isAutoTokenAssociationEnabled: boolean;
+  delegation: HederaDelegation | null;
 }
 
 export interface HederaResourcesRaw {
   maxAutomaticTokenAssociations: number;
   isAutoTokenAssociationEnabled: boolean;
+  delegation: HederaDelegationRaw | null;
 }
 
 export type HederaAccount = Account & {
@@ -95,6 +169,37 @@ export type HederaOperationExtra = {
   gasLimit?: number;
   gasUsed?: number;
   memo?: string | null;
+  targetStakingNodeId?: number | null;
+  previousStakingNodeId?: number | null;
+};
+
+export type HederaValidator = {
+  nodeId: number;
+  minStake: BigNumber;
+  maxStake: BigNumber;
+  activeStake: BigNumber;
+  activeStakePercentage: BigNumber;
+  address: string;
+  addressChecksum: string | null;
+  name: string;
+  overstaked: boolean;
+};
+
+export type HederaValidatorRaw = {
+  nodeId: number;
+  minStake: string;
+  maxStake: string;
+  activeStake: string;
+  activeStakePercentage: string;
+  address: string;
+  addressChecksum: string | null;
+  name: string;
+  overstaked: boolean;
+};
+
+export type HederaPreloadData = {
+  validators: HederaValidator[];
+  associatedTokenId?: string;
 };
 
 export type HederaOperation = Operation<HederaOperationExtra>;

package/src/types/logic.ts

@@ -13,7 +13,7 @@ export type EstimateFeesParams =
       operationType: Exclude<HEDERA_OPERATION_TYPES, HEDERA_OPERATION_TYPES.ContractCall>;
     }
   | {
-      operationType: typeof HEDERA_OPERATION_TYPES.ContractCall;
+      operationType: HEDERA_OPERATION_TYPES.ContractCall;
       txIntent: TransactionIntent;
     };
 
@@ -42,3 +42,8 @@ export interface ERC20OperationFields {
   standard: "erc20";
   hasFailed: false;
 }
+
+export interface OperationDetailsExtraField {
+  key: string;
+  value: string | number;
+}