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

package/src/logic/craftTransaction.ts

@@ -2,6 +2,7 @@ import BigNumber from "bignumber.js";
 import invariant from "invariant";
 import {
   AccountId,
+  AccountUpdateTransaction,
   ContractExecuteTransaction,
   ContractFunctionParameters,
   ContractId,
@@ -13,7 +14,7 @@ import {
 import type { FeeEstimation, TransactionIntent } from "@ledgerhq/coin-framework/api/index";
 import { DEFAULT_GAS_LIMIT, HEDERA_TRANSACTION_MODES } from "../constants";
 import type { HederaMemo, HederaTxData } from "../types";
-import { serializeTransaction } from "./utils";
+import { hasSpecificIntentData, serializeTransaction } from "./utils";
 
 // avoid "sign" prompt loop by having only one node (one transaction)
 // https://github.com/LedgerHQ/ledger-live/pull/72/commits/1e942687d4301660e43e0c4b5419fcfa2733b290
@@ -55,6 +56,14 @@ interface BuilderTokenAssociateTransaction extends BuilderCommonTransactionField
   tokenId: string;
 }
 
+interface BuilderUpdateAccountTransaction extends BuilderCommonTransactionFields {
+  type:
+    | HEDERA_TRANSACTION_MODES.Delegate
+    | HEDERA_TRANSACTION_MODES.Undelegate
+    | HEDERA_TRANSACTION_MODES.Redelegate;
+  stakingNodeId: number | null | undefined;
+}
+
 async function buildUnsignedCoinTransaction({
   account,
   transaction,
@@ -159,13 +168,42 @@ async function buildTokenAssociateTransaction({
   return tx.freeze();
 }
 
+async function buildUnsignedUpdateAccountTransaction({
+  account,
+  transaction,
+}: {
+  account: BuilderOperator;
+  transaction: BuilderUpdateAccountTransaction;
+}): Promise<AccountUpdateTransaction> {
+  const accountId = account.accountId;
+
+  const tx = new AccountUpdateTransaction()
+    .setNodeAccountIds([new AccountId(3)])
+    .setTransactionId(TransactionId.generate(accountId))
+    .setTransactionMemo(transaction.memo ?? "")
+    .setAccountId(accountId);
+
+  if (transaction.maxFee) {
+    tx.setMaxTransactionFee(Hbar.fromTinybars(transaction.maxFee.toNumber()));
+  }
+
+  if (typeof transaction.stakingNodeId === "number") {
+    tx.setStakedNodeId(transaction.stakingNodeId);
+  }
+
+  if (transaction.stakingNodeId === null) {
+    tx.clearStakedNodeId();
+  }
+
+  return tx.freeze();
+}
+
 export async function craftTransaction(
   txIntent: TransactionIntent<HederaMemo, HederaTxData>,
   customFees?: FeeEstimation,
 ) {
-  const account = {
-    accountId: txIntent.sender,
-  };
+  const account = { accountId: txIntent.sender };
+  const maxFee = customFees ? new BigNumber(customFees.value.toString()) : undefined;
 
   let tx;
 
@@ -179,7 +217,7 @@ export async function craftTransaction(
         type: txIntent.type,
         tokenId: txIntent.asset.assetReference,
         memo: txIntent.memo.value,
-        maxFee: customFees ? new BigNumber(customFees.value.toString()) : undefined,
+        maxFee,
       },
     });
   } else if (txIntent.type === HEDERA_TRANSACTION_MODES.Send && txIntent.asset.type === "hts") {
@@ -195,17 +233,16 @@ export async function craftTransaction(
         amount,
         recipient: txIntent.recipient,
         memo: txIntent.memo.value,
-        maxFee: customFees ? new BigNumber(customFees.value.toString()) : undefined,
+        maxFee,
       },
     });
   } else if (txIntent.type === HEDERA_TRANSACTION_MODES.Send && txIntent.asset.type === "erc20") {
     invariant("assetReference" in txIntent.asset, "hedera: no assetReference in token transfer");
 
     const amount = new BigNumber(txIntent.amount.toString());
-    const gasLimit =
-      "data" in txIntent && txIntent.data.gasLimit
-        ? new BigNumber(txIntent.data.gasLimit.toString())
-        : DEFAULT_GAS_LIMIT;
+    const gasLimit = hasSpecificIntentData(txIntent, "erc20")
+      ? new BigNumber(txIntent.data.gasLimit.toString())
+      : DEFAULT_GAS_LIMIT;
 
     tx = await buildUnsignedERC20TokenTransaction({
       account,
@@ -215,11 +252,31 @@ export async function craftTransaction(
         amount,
         recipient: txIntent.recipient,
         memo: txIntent.memo.value,
-        maxFee: customFees ? new BigNumber(customFees.value.toString()) : undefined,
+        maxFee,
         gasLimit,
       },
     });
-  } else {
+  } else if (
+    txIntent.type === HEDERA_TRANSACTION_MODES.Redelegate ||
+    txIntent.type === HEDERA_TRANSACTION_MODES.Undelegate ||
+    txIntent.type === HEDERA_TRANSACTION_MODES.Delegate
+  ) {
+    const stakingNodeId = hasSpecificIntentData(txIntent, "staking")
+      ? txIntent.data.stakingNodeId
+      : undefined;
+
+    tx = await buildUnsignedUpdateAccountTransaction({
+      account,
+      transaction: {
+        type: txIntent.type,
+        memo: txIntent.memo.value,
+        maxFee,
+        stakingNodeId,
+      },
+    });
+  }
+  // HEDERA_TRANSACTION_MODES.ClaimRewards is just a coin transfer that triggers staking rewards claim
+  else {
     const amount = new BigNumber(txIntent.amount.toString());
 
     tx = await buildUnsignedCoinTransaction({
@@ -229,7 +286,7 @@ export async function craftTransaction(
         amount,
         recipient: txIntent.recipient,
         memo: txIntent.memo.value,
-        maxFee: customFees ? new BigNumber(customFees.value.toString()) : undefined,
+        maxFee,
       },
     });
   }

package/src/logic/getBalance.test.ts

@@ -29,7 +29,6 @@ describe("getBalance", () => {
     expect(apiClient.getAccount).toHaveBeenCalledWith(address);
     expect(apiClient.getAccountTokens).toHaveBeenCalledTimes(1);
     expect(apiClient.getAccountTokens).toHaveBeenCalledWith(address);
-    expect(result).toHaveLength(1);
     expect(result).toEqual([
       {
         asset: { type: "native" },
@@ -80,7 +79,6 @@ describe("getBalance", () => {
     expect(apiClient.getAccountTokens).toHaveBeenCalledWith(address);
     expect(findTokenByAddressInCurrencyMock).toHaveBeenCalledTimes(1);
     expect(findTokenByAddressInCurrencyMock).toHaveBeenCalledWith("0.0.7890", "hedera");
-    expect(result).toHaveLength(2);
     expect(result).toEqual(
       expect.arrayContaining([
         {
@@ -150,21 +148,22 @@ describe("getBalance", () => {
 
     const result = await getBalance(mockCurrency, address);
 
-    expect(result).toHaveLength(2);
-    expect(result[0]).toEqual({
-      asset: { type: "native" },
-      value: BigInt("1000000000"),
-    });
-    expect(result[1]).toEqual({
-      value: BigInt("5000"),
-      asset: {
-        type: mockTokenHTS.tokenType,
-        assetReference: mockTokenHTS.contractAddress,
-        assetOwner: address,
-        name: mockTokenHTS.name,
-        unit: mockTokenHTS.units[0],
+    expect(result).toEqual([
+      {
+        asset: { type: "native" },
+        value: BigInt("1000000000"),
       },
-    });
+      {
+        value: BigInt("5000"),
+        asset: {
+          type: mockTokenHTS.tokenType,
+          assetReference: mockTokenHTS.contractAddress,
+          assetOwner: address,
+          name: mockTokenHTS.name,
+          unit: mockTokenHTS.units[0],
+        },
+      },
+    ]);
   });
 
   it("should throw when failing to getAccount data", async () => {

package/src/logic/getBlock.ts

@@ -7,7 +7,7 @@ import type {
 import { getBlockInfo } from "./getBlockInfo";
 import { apiClient } from "../network/api";
 import type { HederaMirrorCoinTransfer, HederaMirrorTokenTransfer } from "../types";
-import { getTimestampRangeFromBlockHeight } from "./utils";
+import { getMemoFromBase64, getTimestampRangeFromBlockHeight } from "./utils";
 
 function toHederaAsset(
   mirrorTransfer: HederaMirrorCoinTransfer | HederaMirrorTokenTransfer,
@@ -64,6 +64,7 @@ export async function getBlock(height: number): Promise<Block> {
       operations,
       fees: BigInt(tx.charged_tx_fee),
       feesPayer: payerAccount,
+      details: { memo: getMemoFromBase64(tx.memo_base64) },
     };
   });
 

package/src/logic/listOperations.test.ts

@@ -1,11 +1,14 @@
+import BigNumber from "bignumber.js";
+import { setupMockCryptoAssetsStore } from "@ledgerhq/cryptoassets/cal-client/test-helpers";
 import { encodeTokenAccountId } from "@ledgerhq/coin-framework/account/accountId";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
 import type { Pagination } from "@ledgerhq/coin-framework/api/types";
+import { getEnv } from "@ledgerhq/live-env";
 import { listOperations } from "./listOperations";
 import { apiClient } from "../network/api";
 import { getMockedCurrency } from "../test/fixtures/currency.fixture";
+import type { HederaMirrorTransaction } from "../types";
 import * as utils from "./utils";
-import { setupMockCryptoAssetsStore } from "@ledgerhq/cryptoassets/cal-client/test-helpers";
 
 setupMockCryptoAssetsStore();
 jest.mock("@ledgerhq/coin-framework/account/accountId");
@@ -73,7 +76,7 @@ describe("listOperations", () => {
       order: "desc",
     };
 
-    const mockTransactions = [
+    const mockTransactions: Partial<HederaMirrorTransaction>[] = [
       {
         consensus_timestamp: "1625097600.000000000",
         transaction_hash: "hash1",
@@ -81,9 +84,10 @@ describe("listOperations", () => {
         result: "SUCCESS",
         memo_base64: "test-memo",
         token_transfers: [],
+        staking_reward_transfers: [],
         transfers: [
-          { account: address, amount: "-1000000" },
-          { account: "0.0.67890", amount: "1000000" },
+          { account: address, amount: -1000000 },
+          { account: "0.0.67890", amount: 1000000 },
         ],
         name: "CRYPTOTRANSFER",
       },
@@ -105,9 +109,8 @@ describe("listOperations", () => {
       useSyntheticBlocks: false,
     });
 
-    expect(result.coinOperations).toHaveLength(1);
     expect(result.tokenOperations).toEqual([]);
-
+    expect(result.coinOperations).toHaveLength(1);
     expect(result.coinOperations).toMatchObject([
       {
         type: "OUT",
@@ -144,16 +147,17 @@ describe("listOperations", () => {
       units: [{ name: "TT", code: "tt", magnitude: 6 }],
     };
 
-    const mockTransactions = [
+    const mockTransactions: Partial<HederaMirrorTransaction>[] = [
       {
         consensus_timestamp: "1625097600.000000000",
         transaction_hash: "hash1",
         charged_tx_fee: 500000,
         result: "SUCCESS",
         token_transfers: [
-          { token_id: tokenId, account: address, amount: "-1000" },
-          { token_id: tokenId, account: "0.0.67890", amount: "1000" },
+          { token_id: tokenId, account: address, amount: -1000 },
+          { token_id: tokenId, account: "0.0.67890", amount: 1000 },
         ],
+        staking_reward_transfers: [],
         transfers: [],
         name: "CRYPTOTRANSFER",
       },
@@ -180,16 +184,12 @@ describe("listOperations", () => {
       useSyntheticBlocks: false,
     });
 
-    expect(result.coinOperations).toHaveLength(1);
-    expect(result.tokenOperations).toHaveLength(1);
-
     expect(result.coinOperations).toMatchObject([
       {
         type: "FEES",
         fee: expect.any(Object),
       },
     ]);
-
     expect(result.tokenOperations).toMatchObject([
       {
         type: "OUT",
@@ -216,14 +216,15 @@ describe("listOperations", () => {
       order: "desc",
     };
 
-    const mockTransactions = [
+    const mockTransactions: Partial<HederaMirrorTransaction>[] = [
       {
         consensus_timestamp: "1625097600.000000000",
         transaction_hash: "hash1",
         charged_tx_fee: 500000,
         result: "SUCCESS",
         token_transfers: [],
-        transfers: [{ account: address, amount: "-500000" }],
+        staking_reward_transfers: [],
+        transfers: [{ account: address, amount: -500000 }],
         name: "TOKENASSOCIATE",
       },
     ];
@@ -244,9 +245,7 @@ describe("listOperations", () => {
       useSyntheticBlocks: false,
     });
 
-    expect(result.coinOperations).toHaveLength(1);
-    expect(result.tokenOperations).toHaveLength(0);
-
+    expect(result.tokenOperations).toEqual([]);
     expect(result.coinOperations).toMatchObject([
       {
         type: "ASSOCIATE_TOKEN",
@@ -273,16 +272,17 @@ describe("listOperations", () => {
       order: "desc",
     };
 
-    const mockTransactions = [
+    const mockTransactions: Partial<HederaMirrorTransaction>[] = [
       {
         consensus_timestamp: "1625097600.000000000",
         transaction_hash: "hash1",
         charged_tx_fee: 500000,
         result: "SUCCESS",
         token_transfers: [
-          { token_id: tokenId, account: address, amount: "-1000" },
-          { token_id: tokenId, account: "0.0.67890", amount: "1000" },
+          { token_id: tokenId, account: address, amount: -1000 },
+          { token_id: tokenId, account: "0.0.67890", amount: 1000 },
         ],
+        staking_reward_transfers: [],
         transfers: [],
         name: "CRYPTOTRANSFER",
       },
@@ -309,8 +309,8 @@ describe("listOperations", () => {
       useSyntheticBlocks: false,
     });
 
-    expect(result.coinOperations).toHaveLength(0);
-    expect(result.tokenOperations).toHaveLength(0);
+    expect(result.coinOperations).toEqual([]);
+    expect(result.tokenOperations).toEqual([]);
   });
 
   it("should use pagination parameters correctly", async () => {
@@ -358,17 +358,18 @@ describe("listOperations", () => {
       order: "desc",
     };
 
-    const mockTransactions = [
+    const mockTransactions: Partial<HederaMirrorTransaction>[] = [
       {
         consensus_timestamp: "1625097600.000000000",
         transaction_hash: "hash1",
         charged_tx_fee: 500000,
         result: "INVALID_SIGNATURE",
-        memo_base64: null,
+        memo_base64: "",
         token_transfers: [],
+        staking_reward_transfers: [],
         transfers: [
-          { account: address, amount: "-1000000" },
-          { account: "0.0.67890", amount: "1000000" },
+          { account: address, amount: -1000000 },
+          { account: "0.0.67890", amount: 1000000 },
         ],
         name: "CRYPTOTRANSFER",
       },
@@ -390,7 +391,63 @@ describe("listOperations", () => {
       useSyntheticBlocks: false,
     });
 
-    expect(result.coinOperations).toHaveLength(1);
-    expect(result.coinOperations[0].hasFailed).toBe(true);
+    expect(result.coinOperations).toMatchObject([{ hasFailed: true }]);
+  });
+
+  it("should create REWARD operation when staking rewards are present", async () => {
+    const address = "0.0.1234567";
+    const mockCurrency = getMockedCurrency();
+    const pagination: Pagination = {
+      minHeight: 0,
+      limit: 10,
+      order: "desc",
+    };
+    const mockTransaction: Partial<HederaMirrorTransaction> = {
+      consensus_timestamp: "1625097600.000000000",
+      transaction_hash: "hash1",
+      charged_tx_fee: 500000,
+      result: "SUCCESS",
+      memo_base64: "",
+      token_transfers: [],
+      staking_reward_transfers: [{ account: address, amount: 1000000 }],
+      transfers: [{ account: address, amount: -500000 }],
+      name: "CRYPTOTRANSFER",
+    };
+
+    (apiClient.getAccountTransactions as jest.Mock).mockResolvedValue({
+      transactions: [mockTransaction],
+      nextCursor: null,
+    });
+
+    const result = await listOperations({
+      currency: mockCurrency,
+      address,
+      pagination,
+      mirrorTokens: [],
+      fetchAllPages: true,
+      skipFeesForTokenOperations: false,
+      useEncodedHash: false,
+      useSyntheticBlocks: false,
+    });
+
+    const rewardTimestamp = result.coinOperations[0].date.getTime();
+    const mainTimestamp = result.coinOperations[1].date.getTime();
+
+    expect(result.tokenOperations).toEqual([]);
+    expect(rewardTimestamp).toBe(mainTimestamp + 1);
+    expect(result.coinOperations).toMatchObject([
+      {
+        type: "REWARD",
+        hash: `${mockTransaction.transaction_hash}-staking-reward`,
+        value: new BigNumber(1000000),
+        fee: new BigNumber(0),
+        senders: [getEnv("HEDERA_STAKING_REWARD_ACCOUNT_ID")],
+        recipients: [address],
+      },
+      {
+        type: "OUT",
+        hash: mockTransaction.transaction_hash,
+      },
+    ]);
   });
 });

package/src/logic/listOperations.ts

@@ -1,4 +1,5 @@
 import BigNumber from "bignumber.js";
+import { getEnv } from "@ledgerhq/live-env";
 import type { Operation, OperationType } from "@ledgerhq/types-live";
 import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
 import type { Pagination } from "@ledgerhq/coin-framework/api/types";
@@ -13,6 +14,7 @@ import { base64ToUrlSafeBase64, getMemoFromBase64, getSyntheticBlock } from "./u
 const txNameToCustomOperationType: Record<string, OperationType> = {
   TOKENASSOCIATE: "ASSOCIATE_TOKEN",
   CONTRACTCALL: "CONTRACT_CALL",
+  CRYPTOUPDATEACCOUNT: "UPDATE_ACCOUNT",
 };
 
 function getCommonOperationData(
@@ -133,14 +135,27 @@ function processTransfers({
   ledgerAccountId: string;
   commonData: ReturnType<typeof getCommonOperationData>;
   mirrorTokens: HederaMirrorToken[];
-}): Operation<HederaOperationExtra> | null {
+}): Operation<HederaOperationExtra>[] {
+  const coinOperations: Operation<HederaOperationExtra>[] = [];
   const transfers = rawTx.transfers ?? [];
-  if (transfers.length === 0) return null;
+
+  if (transfers.length === 0) {
+    return [];
+  }
 
   const { type, value, senders, recipients } = parseTransfers(transfers, address);
   const { hash, fee, timestamp, blockHeight, blockHash, hasFailed } = commonData;
   const extra = { ...commonData.extra };
   const operationType = txNameToCustomOperationType[rawTx.name] ?? type;
+  const stakingReward = rawTx.staking_reward_transfers.reduce((acc, transfer) => {
+    const transferAmount = new BigNumber(transfer.amount);
+
+    if (transfer.account === address) {
+      acc = acc.plus(transferAmount);
+    }
+
+    return acc;
+  }, new BigNumber(0));
 
   // try to enrich ASSOCIATE_TOKEN operation with extra.associatedTokenId
   // this value is used by custom OperationDetails components in Hedera family
@@ -155,7 +170,30 @@ function processTransfers({
     }
   }
 
-  return {
+  // add REWARD operation representing staking reward transfers
+  if (stakingReward.gt(0)) {
+    const stakingRewardHash = `${hash}-staking-reward`;
+    const stakingRewardType: OperationType = "REWARD";
+    // offset timestamp by +1ms to ensure it appears just before the operation that triggered it
+    const stakingRewardTimestamp = new Date(timestamp.getTime() + 1);
+
+    coinOperations.push({
+      id: encodeOperationId(ledgerAccountId, stakingRewardHash, stakingRewardType),
+      accountId: ledgerAccountId,
+      type: stakingRewardType,
+      value: stakingReward,
+      recipients: [address],
+      senders: [getEnv("HEDERA_STAKING_REWARD_ACCOUNT_ID")],
+      hash: stakingRewardHash,
+      fee: new BigNumber(0),
+      date: stakingRewardTimestamp,
+      blockHeight,
+      blockHash,
+      extra,
+    });
+  }
+
+  coinOperations.push({
     id: encodeOperationId(ledgerAccountId, hash, operationType),
     accountId: ledgerAccountId,
     type: operationType,
@@ -169,7 +207,9 @@ function processTransfers({
     blockHash,
     hasFailed,
     extra,
-  };
+  });
+
+  return coinOperations;
 }
 
 export async function listOperations({
@@ -231,7 +271,7 @@ export async function listOperations({
 
     // process regular transfers only if there were no token transfers
     if (!tokenResult) {
-      const coinOperation = processTransfers({
+      const newCoinOperations = processTransfers({
         rawTx,
         address,
         ledgerAccountId,
@@ -239,7 +279,7 @@ export async function listOperations({
         mirrorTokens,
       });
 
-      if (coinOperation) coinOperations.push(coinOperation);
+      coinOperations.push(...newCoinOperations);
     }
   }