@ledgerhq/coin-hedera 1.13.0-nightly.2 → 1.13.0-nightly.3

package/src/bridge/buildOptimisticOperation.ts

@@ -2,10 +2,10 @@ import invariant from "invariant";
 import type { Account, Operation, OperationType, TokenAccount } from "@ledgerhq/types-live";
 import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
 import { findSubAccountById, isTokenAccount } from "@ledgerhq/coin-framework/account/helpers";
-import type { HederaOperationExtra, Transaction } from "../types";
-import { getEstimatedFees, safeParseAccountId } from "./utils";
-import { isTokenAssociateTransaction } from "../logic";
 import { HEDERA_OPERATION_TYPES } from "../constants";
+import { estimateFees } from "../logic/estimateFees";
+import { isTokenAssociateTransaction, safeParseAccountId } from "../logic/utils";
+import type { HederaOperationExtra, Transaction } from "../types";
 
 const buildOptimisticTokenAssociateOperation = async ({
   account,
@@ -16,15 +16,14 @@ const buildOptimisticTokenAssociateOperation = async ({
 }): Promise<Operation> => {
   invariant(isTokenAssociateTransaction(transaction), "invalid transaction properties");
 
-  const estimatedFee = await getEstimatedFees(account, HEDERA_OPERATION_TYPES.TokenAssociate);
-  const value = transaction.amount;
+  const estimatedFee = await estimateFees(account.currency, HEDERA_OPERATION_TYPES.TokenAssociate);
   const type: OperationType = "ASSOCIATE_TOKEN";
 
   const operation: Operation = {
     id: encodeOperationId(account.id, "", type),
     hash: "",
     type,
-    value,
+    value: estimatedFee,
     fee: estimatedFee,
     blockHash: null,
     blockHeight: null,
@@ -52,7 +51,7 @@ const buildOptimisticCoinOperation = async ({
   const estimatedFee =
     transactionType === "FEES"
       ? transaction.amount
-      : await getEstimatedFees(account, HEDERA_OPERATION_TYPES.CryptoTransfer);
+      : await estimateFees(account.currency, HEDERA_OPERATION_TYPES.CryptoTransfer);
   const value = transaction.amount;
   const type: OperationType = transactionType ?? "OUT";
   const [_, recipientAddress] = safeParseAccountId(transaction.recipient);
@@ -70,7 +69,9 @@ const buildOptimisticCoinOperation = async ({
     recipients: [recipientWithoutChecksum],
     accountId: account.id,
     date: new Date(),
-    extra: {},
+    extra: {
+      ...(!!transaction.memo && { memo: transaction.memo }),
+    },
   };
 
   return operation;
@@ -85,7 +86,7 @@ const buildOptimisticTokenOperation = async ({
   tokenAccount: TokenAccount;
   transaction: Transaction;
 }): Promise<Operation> => {
-  const estimatedFee = await getEstimatedFees(account, HEDERA_OPERATION_TYPES.TokenTransfer);
+  const estimatedFee = await estimateFees(account.currency, HEDERA_OPERATION_TYPES.TokenTransfer);
   const value = transaction.amount;
   const type: OperationType = "OUT";
   const [_, recipientAddress] = safeParseAccountId(transaction.recipient);
@@ -116,7 +117,9 @@ const buildOptimisticTokenOperation = async ({
         recipients: [recipientWithoutChecksum],
         accountId: tokenAccount.id,
         date: new Date(),
-        extra: {},
+        extra: {
+          ...(!!transaction.memo && { memo: transaction.memo }),
+        },
       },
     ],
   };

package/src/bridge/createTransaction.ts

@@ -1,6 +1,7 @@
 import BigNumber from "bignumber.js";
 import { AccountBridge } from "@ledgerhq/types-live";
-import { Transaction } from "../types";
+import { HEDERA_TRANSACTION_MODES } from "../constants";
+import type { Transaction } from "../types";
 
 /**
  * Creates an empty transaction.
@@ -8,6 +9,7 @@ import { Transaction } from "../types";
  * @returns {Transaction}
  */
 export const createTransaction: AccountBridge<Transaction>["createTransaction"] = () => ({
+  mode: HEDERA_TRANSACTION_MODES.Send,
   family: "hedera",
   amount: new BigNumber(0),
   recipient: "",

package/src/bridge/estimateMaxSpendable.ts

@@ -2,9 +2,9 @@ import BigNumber from "bignumber.js";
 import type { AccountBridge } from "@ledgerhq/types-live";
 import { getMainAccount } from "@ledgerhq/coin-framework/account/index";
 import { isTokenAccount } from "@ledgerhq/coin-framework/account/helpers";
-import type { Transaction } from "../types";
-import { getEstimatedFees } from "./utils";
 import { HEDERA_OPERATION_TYPES } from "../constants";
+import { estimateFees } from "../logic/estimateFees";
+import type { Transaction } from "../types";
 
 export const estimateMaxSpendable: AccountBridge<Transaction>["estimateMaxSpendable"] = async ({
   account,
@@ -18,7 +18,10 @@ export const estimateMaxSpendable: AccountBridge<Transaction>["estimateMaxSpenda
     return Promise.resolve(balance);
   }
 
-  const estimatedFees = await getEstimatedFees(mainAccount, HEDERA_OPERATION_TYPES.CryptoTransfer);
+  const estimatedFees = await estimateFees(
+    mainAccount.currency,
+    HEDERA_OPERATION_TYPES.CryptoTransfer,
+  );
   let maxSpendable = balance.minus(estimatedFees);
 
   // set max spendable to 0 if negative

package/src/bridge/getTransactionStatus.test.ts

@@ -5,18 +5,19 @@ import {
   AmountRequired,
   NotEnoughBalance,
 } from "@ledgerhq/errors";
+import { HEDERA_TRANSACTION_MODES } from "../constants";
 import {
   HederaRecipientInvalidChecksum,
   HederaInsufficientFundsForAssociation,
   HederaRecipientTokenAssociationRequired,
   HederaRecipientTokenAssociationUnverified,
 } from "../errors";
+import { getTransactionStatus } from "./getTransactionStatus";
+import * as estimateFees from "../logic/estimateFees";
+import * as logicUtils from "../logic/utils";
 import { getMockedAccount, getMockedTokenAccount } from "../test/fixtures/account.fixture";
 import { getMockedTokenCurrency } from "../test/fixtures/currency.fixture";
 import { getMockedTransaction } from "../test/fixtures/transaction.fixture";
-import { getTransactionStatus } from "./getTransactionStatus";
-import * as utils from "./utils";
-import { HEDERA_TRANSACTION_KINDS } from "../constants";
 
 describe("getTransactionStatus", () => {
   const mockedEstimatedFee = new BigNumber(1);
@@ -27,8 +28,8 @@ describe("getTransactionStatus", () => {
   beforeEach(() => {
     jest.clearAllMocks();
 
-    jest.spyOn(utils, "getCurrencyToUSDRate").mockResolvedValueOnce(mockedUsdRate);
-    jest.spyOn(utils, "getEstimatedFees").mockResolvedValueOnce(mockedEstimatedFee);
+    jest.spyOn(logicUtils, "getCurrencyToUSDRate").mockResolvedValueOnce(mockedUsdRate);
+    jest.spyOn(estimateFees, "estimateFees").mockResolvedValueOnce(mockedEstimatedFee);
   });
 
   test("coin transfer with valid recipient and sufficient balance completes successfully", async () => {
@@ -47,7 +48,7 @@ describe("getTransactionStatus", () => {
   });
 
   test("token transfer with valid recipient and sufficient balance completes successfully", async () => {
-    jest.spyOn(utils, "checkAccountTokenAssociationStatus").mockResolvedValueOnce(true);
+    jest.spyOn(logicUtils, "checkAccountTokenAssociationStatus").mockResolvedValueOnce(true);
 
     const tokenCurrency = getMockedTokenCurrency();
     const tokenAccount = getMockedTokenAccount(tokenCurrency, { balance: new BigNumber(500) });
@@ -69,8 +70,8 @@ describe("getTransactionStatus", () => {
     const mockedTokenCurrency = getMockedTokenCurrency();
     const mockedAccount = getMockedAccount();
     const mockedTransaction = getMockedTransaction({
+      mode: HEDERA_TRANSACTION_MODES.TokenAssociate,
       properties: {
-        name: HEDERA_TRANSACTION_KINDS.TokenAssociate.name,
         token: mockedTokenCurrency,
       },
     });
@@ -139,8 +140,8 @@ describe("getTransactionStatus", () => {
     const mockedTokenCurrency = getMockedTokenCurrency();
     const mockedAccount = getMockedAccount({ balance: new BigNumber(0) });
     const mockedTransaction = getMockedTransaction({
+      mode: HEDERA_TRANSACTION_MODES.TokenAssociate,
       properties: {
-        name: HEDERA_TRANSACTION_KINDS.TokenAssociate.name,
         token: mockedTokenCurrency,
       },
     });
@@ -153,7 +154,7 @@ describe("getTransactionStatus", () => {
   });
 
   test("adds warning during token transfer if recipient has no token associated", async () => {
-    jest.spyOn(utils, "checkAccountTokenAssociationStatus").mockResolvedValueOnce(false);
+    jest.spyOn(logicUtils, "checkAccountTokenAssociationStatus").mockResolvedValueOnce(false);
 
     const mockedTokenCurrency = getMockedTokenCurrency();
     const mockedTokenAccount = getMockedTokenAccount(mockedTokenCurrency);
@@ -172,7 +173,7 @@ describe("getTransactionStatus", () => {
 
   test("adds warning if token association status can't be verified", async () => {
     jest
-      .spyOn(utils, "checkAccountTokenAssociationStatus")
+      .spyOn(logicUtils, "checkAccountTokenAssociationStatus")
       .mockRejectedValueOnce(new HederaRecipientTokenAssociationUnverified());
 
     const mockedTokenCurrency = getMockedTokenCurrency();

package/src/bridge/getTransactionStatus.ts

@@ -8,21 +8,22 @@ import {
 import type { Account, AccountBridge, TokenAccount } from "@ledgerhq/types-live";
 import { findSubAccountById, isTokenAccount } from "@ledgerhq/coin-framework/account";
 import { getEnv } from "@ledgerhq/live-env";
+import { HEDERA_OPERATION_TYPES } from "../constants";
 import {
   HederaInsufficientFundsForAssociation,
   HederaRecipientTokenAssociationRequired,
   HederaRecipientTokenAssociationUnverified,
 } from "../errors";
-import { isTokenAssociateTransaction, isTokenAssociationRequired } from "../logic";
-import type { TokenAssociateProperties, Transaction, TransactionStatus } from "../types";
+import { estimateFees } from "../logic/estimateFees";
 import {
-  calculateAmount,
-  checkAccountTokenAssociationStatus,
+  isTokenAssociateTransaction,
+  isTokenAssociationRequired,
   getCurrencyToUSDRate,
-  getEstimatedFees,
+  checkAccountTokenAssociationStatus,
   safeParseAccountId,
-} from "./utils";
-import { HEDERA_OPERATION_TYPES } from "../constants";
+} from "../logic/utils";
+import type { Transaction, TransactionStatus, TransactionTokenAssociate } from "../types";
+import { calculateAmount } from "./utils";
 
 type Errors = Record<string, Error>;
 type Warnings = Record<string, Error>;
@@ -49,14 +50,14 @@ function validateRecipient(account: Account, recipient: string): Error | null {
 
 async function handleTokenAssociateTransaction(
   account: Account,
-  transaction: Extract<Required<Transaction>, { properties: TokenAssociateProperties }>,
+  transaction: TransactionTokenAssociate,
 ): Promise<TransactionStatus> {
   const errors: Errors = {};
   const warnings: Warnings = {};
 
   const [usdRate, estimatedFees] = await Promise.all([
     getCurrencyToUSDRate(account.currency),
-    getEstimatedFees(account, HEDERA_OPERATION_TYPES.TokenAssociate),
+    estimateFees(account.currency, HEDERA_OPERATION_TYPES.TokenAssociate),
   ]);
 
   const amount = BigNumber(0);
@@ -93,7 +94,7 @@ async function handleTokenTransaction(
   const warnings: Warnings = {};
   const [calculatedAmount, estimatedFees] = await Promise.all([
     calculateAmount({ transaction, account }),
-    getEstimatedFees(account, HEDERA_OPERATION_TYPES.TokenTransfer),
+    estimateFees(account.currency, HEDERA_OPERATION_TYPES.TokenTransfer),
   ]);
 
   const recipientError = validateRecipient(account, transaction.recipient);
@@ -146,7 +147,7 @@ async function handleCoinTransaction(
   const warnings: Warnings = {};
   const [calculatedAmount, estimatedFees] = await Promise.all([
     calculateAmount({ transaction, account }),
-    getEstimatedFees(account, HEDERA_OPERATION_TYPES.CryptoTransfer),
+    estimateFees(account.currency, HEDERA_OPERATION_TYPES.CryptoTransfer),
   ]);
 
   const recipientError = validateRecipient(account, transaction.recipient);

package/src/bridge/js-estimateMaxSpendable.integration.test.ts

@@ -1,9 +1,9 @@
 import BigNumber from "bignumber.js";
 import { createBridges } from ".";
-import { getEstimatedFees } from "./utils";
+import { HEDERA_OPERATION_TYPES } from "../constants";
+import { estimateFees } from "../logic/estimateFees";
 import { getMockedAccount, getMockedTokenAccount } from "../test/fixtures/account.fixture";
 import { getMockedTokenCurrency } from "../test/fixtures/currency.fixture";
-import { HEDERA_OPERATION_TYPES } from "../constants";
 
 describe("js-estimateMaxSpendable", () => {
   let bridge: ReturnType<typeof createBridges>;
@@ -14,7 +14,10 @@ describe("js-estimateMaxSpendable", () => {
     bridge = createBridges(signer);
 
     const mockedAccount = getMockedAccount();
-    const crypto = await getEstimatedFees(mockedAccount, HEDERA_OPERATION_TYPES.CryptoTransfer);
+    const crypto = await estimateFees(
+      mockedAccount.currency,
+      HEDERA_OPERATION_TYPES.CryptoTransfer,
+    );
 
     estimatedFees = { crypto };
   });

package/src/bridge/prepareTransaction.test.ts

@@ -1,28 +1,20 @@
 import BigNumber from "bignumber.js";
-import type { Account } from "@ledgerhq/types-live";
-import * as utils from "./utils";
+import { estimateFees } from "../logic/estimateFees";
 import { prepareTransaction } from "./prepareTransaction";
-import { Transaction } from "../types";
+import { getMockedAccount } from "../test/fixtures/account.fixture";
+import { getMockedTransaction } from "../test/fixtures/transaction.fixture";
+import * as utils from "./utils";
 
-describe("prepareTransaction", () => {
-  const mockAccount = {
-    id: "hedera:0:testAccount",
-    freshAddress: "0.0.123",
-    spendableBalance: new BigNumber(1000000),
-    currency: { id: "hedera" },
-  } as Account;
+jest.mock("../logic/estimateFees");
 
-  const mockTx = {
-    family: "hedera",
-    amount: new BigNumber(0),
-    recipient: "",
-    useAllAmount: false,
-  } as Transaction;
+describe("prepareTransaction", () => {
+  const mockAccount = getMockedAccount();
+  const mockTx = getMockedTransaction();
 
   beforeEach(() => {
     jest.clearAllMocks();
 
-    jest.spyOn(utils, "getEstimatedFees").mockResolvedValue(Promise.resolve(new BigNumber(10)));
+    (estimateFees as jest.Mock).mockResolvedValue(Promise.resolve(new BigNumber(10)));
     jest
       .spyOn(utils, "calculateAmount")
       .mockResolvedValue(

package/src/bridge/prepareTransaction.ts

@@ -1,9 +1,10 @@
 import { findSubAccountById, isTokenAccount } from "@ledgerhq/coin-framework/account/helpers";
 import type { AccountBridge } from "@ledgerhq/types-live";
-import type { Transaction } from "../types";
-import { calculateAmount, getEstimatedFees } from "./utils";
 import { HEDERA_OPERATION_TYPES } from "../constants";
-import { isTokenAssociateTransaction } from "../logic";
+import { estimateFees } from "../logic/estimateFees";
+import { isTokenAssociateTransaction } from "../logic/utils";
+import type { Transaction } from "../types";
+import { calculateAmount } from "./utils";
 
 /**
  * Gather any more neccessary information for a transaction,
@@ -33,7 +34,7 @@ export const prepareTransaction: AccountBridge<Transaction>["prepareTransaction"
   // i.e. if `useAllAmount` has been toggled to true, this is where it will update the transaction to reflect that action
   const [{ amount }, estimatedFees] = await Promise.all([
     calculateAmount({ account, transaction }),
-    getEstimatedFees(account, operationType),
+    estimateFees(account.currency, operationType),
   ]);
 
   // `maxFee` must be explicitly set to avoid the @hashgraph/sdk default fallback

package/src/bridge/serialization.test.ts

@@ -1,15 +1,15 @@
-import {
-  getMockedAccount,
-  getMockedAccountRaw,
-  mockHederaResources,
-  mockHederaResourcesRaw,
-} from "../test/fixtures/account.fixture";
 import {
   assignFromAccountRaw,
   assignToAccountRaw,
   fromHederaResourcesRaw,
   toHederaResourcesRaw,
 } from "./serialization";
+import {
+  getMockedAccount,
+  getMockedAccountRaw,
+  mockHederaResources,
+  mockHederaResourcesRaw,
+} from "../test/fixtures/account.fixture";
 
 const mockedAccount = getMockedAccount();
 const mockedAccountRaw = getMockedAccountRaw();

package/src/bridge/signOperation.ts

@@ -1,10 +1,19 @@
 import { Observable } from "rxjs";
-import { PublicKey } from "@hashgraph/sdk";
 import { Account, AccountBridge } from "@ledgerhq/types-live";
-import { buildOptimisticOperation } from "./buildOptimisticOperation";
-import { buildUnsignedTransaction } from "../api/network";
+import { AssetInfo, FeeEstimation } from "@ledgerhq/coin-framework/api/types";
 import { SignerContext } from "@ledgerhq/coin-framework/signer";
-import { Transaction, HederaSigner } from "../types";
+import { findSubAccountById, isTokenAccount } from "@ledgerhq/coin-framework/account/helpers";
+import { buildOptimisticOperation } from "./buildOptimisticOperation";
+import { HEDERA_TRANSACTION_MODES } from "../constants";
+import { combine } from "../logic/combine";
+import { craftTransaction } from "../logic/craftTransaction";
+import {
+  serializeSignature,
+  serializeTransaction,
+  getHederaTransactionBodyBytes,
+  isTokenAssociateTransaction,
+} from "../logic/utils";
+import type { Transaction, HederaSigner } from "../types";
 
 export const buildSignOperation =
   (
@@ -18,18 +27,63 @@ export const buildSignOperation =
             type: "device-signature-requested",
           });
 
-          const hederaTransaction = await buildUnsignedTransaction({
-            account,
-            transaction,
-          });
+          let type: Transaction["mode"];
+          let asset: AssetInfo;
+          const accountAddress = account.freshAddress;
+          const accountPublicKey = account.seedIdentifier;
+          const subAccount = findSubAccountById(account, transaction.subAccountId || "");
+          const isTokenTransaction = isTokenAccount(subAccount);
+
+          if (isTokenAssociateTransaction(transaction)) {
+            type = HEDERA_TRANSACTION_MODES.TokenAssociate;
+            asset = {
+              type: transaction.properties.token.tokenType,
+              assetReference: transaction.properties.token.contractAddress,
+            };
+          } else if (isTokenTransaction) {
+            type = HEDERA_TRANSACTION_MODES.Send;
+            asset = {
+              type: subAccount.token.tokenType,
+              assetReference: subAccount.token.contractAddress,
+              assetOwner: accountAddress,
+            };
+          } else {
+            type = HEDERA_TRANSACTION_MODES.Send;
+            asset = {
+              type: "native",
+            };
+          }
+
+          const customFees: FeeEstimation | undefined = transaction.maxFee
+            ? { value: BigInt(transaction.maxFee.toString()) }
+            : undefined;
+
+          const signedTx = await signerContext(deviceId, async signer => {
+            const { tx } = await craftTransaction(
+              {
+                intentType: "transaction",
+                type,
+                asset,
+                amount: BigInt(transaction.amount.toString()),
+                sender: accountAddress,
+                recipient: transaction.recipient,
+                memo: {
+                  kind: "text",
+                  type: "string",
+                  value: transaction.memo ?? "",
+                },
+              },
+              customFees,
+            );
 
-          const accountPublicKey = PublicKey.fromString(account.seedIdentifier);
+            const txBodyBytes = getHederaTransactionBodyBytes(tx);
+            const signatureBytes = await signer.signTransaction(txBodyBytes);
 
-          const res = await signerContext(deviceId, async signer => {
-            await hederaTransaction.signWith(accountPublicKey, async bodyBytes => {
-              return await signer.signTransaction(bodyBytes);
-            });
-            return hederaTransaction.toBytes();
+            return combine(
+              serializeTransaction(tx),
+              serializeSignature(signatureBytes),
+              accountPublicKey,
+            );
           });
 
           o.next({
@@ -45,8 +99,7 @@ export const buildSignOperation =
             type: "signed",
             signedOperation: {
               operation,
-              // NOTE: this needs to match the inverse operation in js-broadcast
-              signature: Buffer.from(res).toString("base64"),
+              signature: signedTx,
             },
           });
 

package/src/bridge/synchronisation.ts

@@ -8,7 +8,9 @@ import type {
 } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import { mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import { encodeAccountId } from "@ledgerhq/coin-framework/account";
-import { getAccount, getAccountsForPublicKey, getAccountTokens } from "../api/mirror";
+import { listOperations } from "../logic/listOperations";
+import { apiClient } from "../network/api";
+import type { HederaAccount } from "../types";
 import {
   getSubAccounts,
   prepareOperations,
@@ -16,8 +18,6 @@ import {
   mergeSubAccounts,
   getSyncHash,
 } from "./utils";
-import type { HederaAccount } from "../types";
-import { getOperationsForAccount } from "../api/utils";
 
 export const getAccountShape: GetAccountShape<HederaAccount> = async (
   info,
@@ -39,8 +39,8 @@ export const getAccountShape: GetAccountShape<HederaAccount> = async (
   // tokens are fetched with separate requests to get "created_timestamp" for each token
   // based on this, ASSOCIATE_TOKEN operations can be connected with tokens
   const [mirrorAccount, mirrorTokens] = await Promise.all([
-    getAccount(address),
-    getAccountTokens(address),
+    apiClient.getAccount(address),
+    apiClient.getAccountTokens(address),
   ]);
 
   const accountBalance = new BigNumber(mirrorAccount.balance.balance);
@@ -53,15 +53,24 @@ export const getAccountShape: GetAccountShape<HederaAccount> = async (
   const pendingOperations = initialAccount?.pendingOperations ?? [];
 
   // grab latest operation's consensus timestamp for incremental sync
+  const latestOperation = oldOperations[0];
   const latestOperationTimestamp =
-    !shouldSyncFromScratch && oldOperations[0]
-      ? new BigNumber(Math.floor(oldOperations[0].date.getTime() / 1000))
+    !shouldSyncFromScratch && latestOperation
+      ? new BigNumber(Math.floor(latestOperation.date.getTime() / 1000))
       : null;
-  const latestAccountOperations = await getOperationsForAccount(
-    liveAccountId,
+  const latestAccountOperations = await listOperations({
+    currency,
     address,
-    latestOperationTimestamp ? latestOperationTimestamp.toString() : null,
-  );
+    mirrorTokens,
+    pagination: {
+      minHeight: 0,
+      ...(latestOperationTimestamp && { lastPagingToken: latestOperationTimestamp.toString() }),
+    },
+    fetchAllPages: true,
+    skipFeesForTokenOperations: false,
+    useEncodedHash: true,
+    useSyntheticBlocks: false,
+  });
 
   const newSubAccounts = await getSubAccounts(
     liveAccountId,
@@ -72,7 +81,6 @@ export const getAccountShape: GetAccountShape<HederaAccount> = async (
   const newOperations = prepareOperations(
     latestAccountOperations.coinOperations,
     latestAccountOperations.tokenOperations,
-    mirrorTokens,
   );
   const enrichedNewOperations = applyPendingExtras(newOperations, pendingOperations);
   const operations = shouldSyncFromScratch
@@ -100,7 +108,7 @@ export const getAccountShape: GetAccountShape<HederaAccount> = async (
 };
 
 export const buildIterateResult: IterateResultBuilder = async ({ result: rootResult }) => {
-  const mirrorAccounts = await getAccountsForPublicKey(rootResult.publicKey);
+  const mirrorAccounts = await apiClient.getAccountsForPublicKey(rootResult.publicKey);
   const addresses = mirrorAccounts.map(a => a.account);
 
   return async ({ currency, derivationMode, index }) => {
@@ -117,7 +125,7 @@ export const buildIterateResult: IterateResultBuilder = async ({ result: rootRes
           address: addresses[index],
           publicKey: addresses[index],
           path: freshAddressPath,
-        } as Result)
+        } satisfies Result)
       : null;
   };
 };