@ledgerhq/coin-hedera 1.10.1 → 1.10.2-nightly.0

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

@@ -1,63 +1,54 @@
 import BigNumber from "bignumber.js";
-import type { Account } from "@ledgerhq/types-live";
 import { createBridges } from ".";
 import { getEstimatedFees } from "./utils";
-
-// Balance is 1 Hbar
-const account: Account = {
-  type: "Account",
-  id: "",
-  seedIdentifier: "",
-  derivationMode: "",
-  index: 0,
-  freshAddress: "",
-  freshAddressPath: "",
-  used: false,
-  balance: new BigNumber(100000000),
-  spendableBalance: new BigNumber(0),
-  creationDate: new Date(),
-  blockHeight: 0,
-  currency: {
-    type: "CryptoCurrency",
-    id: "hedera",
-    managerAppName: "",
-    coinType: 0,
-    scheme: "",
-    color: "",
-    family: "",
-    explorerViews: [],
-    name: "",
-    ticker: "",
-    units: [],
-  },
-  operationsCount: 0,
-  operations: [],
-  pendingOperations: [],
-  lastSyncDate: new Date(),
-  balanceHistoryCache: {
-    HOUR: { latestDate: null, balances: [] },
-    DAY: { latestDate: null, balances: [] },
-    WEEK: { latestDate: null, balances: [] },
-  },
-  swapHistory: [],
-};
+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>;
-  let estimatedFees = new BigNumber("150200").multipliedBy(2); // 0.001502 ℏ (as of 2023-03-14)
+  let estimatedFees: Record<"crypto", BigNumber>;
 
   beforeAll(async () => {
     const signer = jest.fn();
     bridge = createBridges(signer);
-    estimatedFees = await getEstimatedFees(account);
+
+    const mockedAccount = getMockedAccount();
+    const crypto = await getEstimatedFees(mockedAccount, HEDERA_OPERATION_TYPES.CryptoTransfer);
+
+    estimatedFees = { crypto };
+  });
+
+  test("estimateMaxSpendable returns balance minus fee", async () => {
+    const mockedAccount = getMockedAccount();
+
+    const result = await bridge.accountBridge.estimateMaxSpendable({
+      account: mockedAccount,
+    });
+
+    expect(result).toEqual(mockedAccount.balance.minus(estimatedFees.crypto));
+  });
+
+  test("estimateMaxSpendable returns 0 if balance < estimated fees", async () => {
+    const mockedAccount = getMockedAccount({ balance: estimatedFees.crypto.minus(1) });
+
+    const result = await bridge.accountBridge.estimateMaxSpendable({
+      account: mockedAccount,
+    });
+
+    expect(result).toEqual(new BigNumber(0));
   });
 
-  test("estimateMaxSpendable", async () => {
+  test("estimateMaxSpendable returns token balance for token account", async () => {
+    const mockedTokenCurrency = getMockedTokenCurrency();
+    const mockedTokenAccount = getMockedTokenAccount(mockedTokenCurrency);
+    const mockedAccount = getMockedAccount({ subAccounts: [mockedTokenAccount] });
+
     const result = await bridge.accountBridge.estimateMaxSpendable({
-      account,
+      account: mockedTokenAccount,
+      parentAccount: mockedAccount,
     });
-    const data = account.balance.minus(estimatedFees);
 
-    expect(result).toEqual(data);
+    expect(result).toEqual(mockedTokenAccount.balance);
   });
 });

package/src/bridge/js-transaction.test.ts

@@ -1,83 +1,42 @@
 import BigNumber from "bignumber.js";
-import type { Account } from "@ledgerhq/types-live";
 import { updateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
-import type { Transaction } from "../types";
 import { createBridges } from ".";
-
-const account: Account = {
-  type: "Account",
-  id: "",
-  seedIdentifier: "",
-  derivationMode: "",
-  index: 0,
-  freshAddress: "",
-  freshAddressPath: "",
-  used: false,
-  balance: new BigNumber(200000),
-  spendableBalance: new BigNumber(0),
-  creationDate: new Date(),
-  blockHeight: 0,
-  currency: {
-    type: "CryptoCurrency",
-    id: "hedera",
-    managerAppName: "",
-    coinType: 0,
-    scheme: "",
-    color: "",
-    family: "",
-    explorerViews: [],
-    name: "",
-    ticker: "",
-    units: [],
-  },
-  operationsCount: 0,
-  operations: [],
-  pendingOperations: [],
-  lastSyncDate: new Date(),
-  balanceHistoryCache: {
-    HOUR: { latestDate: null, balances: [] },
-    DAY: { latestDate: null, balances: [] },
-    WEEK: { latestDate: null, balances: [] },
-  },
-  swapHistory: [],
-};
-
-const transaction: Transaction = {
-  family: "hedera",
-  amount: new BigNumber(0),
-  recipient: "",
-  useAllAmount: false,
-};
+import { getMockedAccount } from "../test/fixtures/account.fixture";
+import { getMockedTransaction } from "../test/fixtures/transaction.fixture";
+import type { Transaction } from "../types";
 
 describe("js-transaction", () => {
   let bridge: ReturnType<typeof createBridges>;
+  const mockedAccount = getMockedAccount();
+  const mockedTransaction = getMockedTransaction();
 
   beforeAll(() => {
     const signer = jest.fn();
     bridge = createBridges(signer);
   });
+
   test("createTransaction", () => {
-    const data = transaction;
-    const result = bridge.accountBridge.createTransaction(account);
+    const data = mockedTransaction;
+    const result = bridge.accountBridge.createTransaction(mockedAccount);
 
     expect(result).toEqual(data);
   });
 
   test("updateTransaction", () => {
-    const patch = {
+    const patch: Partial<Transaction> = {
       amount: new BigNumber(5),
       recipient: "0.0.3",
       useAllAmount: true,
     };
-    const data = { ...transaction, ...patch };
-    const result = updateTransaction(transaction, patch);
+    const data = { ...mockedTransaction, ...patch };
+    const result = updateTransaction(mockedTransaction, patch);
 
     expect(result).toEqual(data);
   });
 
   test("prepareTransaction", async () => {
-    const data = transaction;
-    const result = await bridge.accountBridge.prepareTransaction(account, transaction);
+    const data = mockedTransaction;
+    const result = await bridge.accountBridge.prepareTransaction(mockedAccount, mockedTransaction);
 
     expect(result).toEqual(data);
   });

package/src/bridge/prepareTransaction.ts

@@ -9,12 +9,11 @@ import { calculateAmount } from "./utils";
  * Hedera has fully client-side transactions and the fee
  * is not possible to estimate ahead-of-time.
  *
- * @returns  {Transaction}
  */
 export const prepareTransaction: AccountBridge<Transaction>["prepareTransaction"] = async (
   account,
   transaction,
-) => {
+): Promise<Transaction> => {
   // explicitly calculate transaction amount to account for `useAllAmount` flag (send max flow)
   // i.e. if `useAllAmount` has been toggled to true, this is where it will update the transaction to reflect that action
   const { amount } = await calculateAmount({ account, transaction });

package/src/bridge/serialization.test.ts

@@ -0,0 +1,39 @@
+import {
+  getMockedAccount,
+  getMockedAccountRaw,
+  mockHederaResources,
+  mockHederaResourcesRaw,
+} from "../test/fixtures/account.fixture";
+import {
+  assignFromAccountRaw,
+  assignToAccountRaw,
+  fromHederaResourcesRaw,
+  toHederaResourcesRaw,
+} from "./serialization";
+
+const mockedAccount = getMockedAccount();
+const mockedAccountRaw = getMockedAccountRaw();
+
+describe("serialization", () => {
+  test("toHederaResourcesRaw should convert HederaResources to HederaResourcesRaw", () => {
+    const result = toHederaResourcesRaw(mockHederaResources);
+    expect(result).toEqual(mockHederaResourcesRaw);
+  });
+
+  test("fromHederaResourcesRaw should convert HederaResourcesRaw to HederaResources", () => {
+    const result = fromHederaResourcesRaw(mockHederaResourcesRaw);
+    expect(result).toEqual(mockHederaResources);
+  });
+
+  test("assignToAccountRaw should assign HederaResources to AccountRaw", () => {
+    assignToAccountRaw(mockedAccount, mockedAccountRaw);
+    expect(typeof mockedAccountRaw.hederaResources).toBe("object");
+    expect(mockedAccountRaw.hederaResources).not.toBeNull();
+  });
+
+  test("assignFromAccountRaw should assign HederaResourcesRaw to Account", () => {
+    assignFromAccountRaw(mockedAccountRaw, mockedAccount);
+    expect(typeof mockedAccountRaw.hederaResources).toBe("object");
+    expect(mockedAccountRaw.hederaResources).not.toBeNull();
+  });
+});

package/src/bridge/serialization.ts

@@ -0,0 +1,43 @@
+import type { AccountRaw, Account } from "@ledgerhq/types-live";
+import type {
+  HederaAccount,
+  HederaAccountRaw,
+  HederaResources,
+  HederaResourcesRaw,
+} from "../types";
+
+export function toHederaResourcesRaw(resources: HederaResources): HederaResourcesRaw {
+  const { maxAutomaticTokenAssociations, isAutoTokenAssociationEnabled } = resources;
+
+  return {
+    maxAutomaticTokenAssociations,
+    isAutoTokenAssociationEnabled,
+  };
+}
+
+export function fromHederaResourcesRaw(rawResources: HederaResourcesRaw): HederaResources {
+  const { maxAutomaticTokenAssociations, isAutoTokenAssociationEnabled } = rawResources;
+
+  return {
+    maxAutomaticTokenAssociations,
+    isAutoTokenAssociationEnabled,
+  };
+}
+
+export function assignToAccountRaw(account: Account, accountRaw: AccountRaw): void {
+  const hederaAccount = account as HederaAccount;
+  const hederaAccountRaw = accountRaw as HederaAccountRaw;
+
+  if (hederaAccount.hederaResources) {
+    hederaAccountRaw.hederaResources = toHederaResourcesRaw(hederaAccount.hederaResources);
+  }
+}
+
+export function assignFromAccountRaw(accountRaw: AccountRaw, account: Account) {
+  const hederaAccount = account as HederaAccount;
+  const hederaAccountRaw = accountRaw as HederaAccountRaw;
+
+  if (hederaAccountRaw.hederaResources) {
+    hederaAccount.hederaResources = fromHederaResourcesRaw(hederaAccountRaw.hederaResources);
+  }
+}

package/src/bridge/synchronisation.ts

@@ -1,23 +1,28 @@
-import invariant from "invariant";
-import {
-  getDerivationScheme,
-  Result,
-  runDerivationScheme,
-} from "@ledgerhq/coin-framework/derivation";
 import { BigNumber } from "bignumber.js";
-import type { Account } from "@ledgerhq/types-live";
-import { getAccountsForPublicKey, getOperationsForAccount } from "../api/mirror";
-import {
+import invariant from "invariant";
+import type { Result } from "@ledgerhq/coin-framework/derivation";
+import { getDerivationScheme, runDerivationScheme } from "@ledgerhq/coin-framework/derivation";
+import type {
   GetAccountShape,
   IterateResultBuilder,
-  mergeOps,
 } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
 import { encodeAccountId } from "@ledgerhq/coin-framework/account";
-import { getAccountBalance } from "../api/network";
+import { getAccount, getAccountsForPublicKey, getAccountTokens } from "../api/mirror";
+import {
+  getSubAccounts,
+  prepareOperations,
+  applyPendingExtras,
+  mergeSubAccounts,
+  getSyncHash,
+} from "./utils";
+import type { HederaAccount } from "../types";
+import { getOperationsForAccount } from "../api/utils";
 
-export const getAccountShape: GetAccountShape<Account> = async (
-  info: any,
-): Promise<Partial<Account>> => {
+export const getAccountShape: GetAccountShape<HederaAccount> = async (
+  info,
+  { blacklistedTokenIds },
+): Promise<Partial<HederaAccount>> => {
   const { currency, derivationMode, address, initialAccount } = info;
 
   invariant(address, "an hedera address is expected");
@@ -30,39 +35,71 @@ export const getAccountShape: GetAccountShape<Account> = async (
     derivationMode,
   });
 
-  // get current account balance
-  const accountBalance = await getAccountBalance(address);
+  // get current account balance and tokens
+  // 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),
+  ]);
+
+  // we should sync again when new tokens are added or blacklist changes
+  const syncHash = getSyncHash(currency, blacklistedTokenIds);
+  const shouldSyncFromScratch = !initialAccount || syncHash !== initialAccount?.syncHash;
 
-  // grab latest operation's consensus timestamp for incremental sync
   const oldOperations = initialAccount?.operations ?? [];
-  const latestOperationTimestamp = oldOperations[0]
-    ? new BigNumber(Math.floor(oldOperations[0].date.getTime() / 1000))
-    : null;
+  const pendingOperations = initialAccount?.pendingOperations ?? [];
 
-  // merge new operations w/ previously synced ones
-  const newOperations = await getOperationsForAccount(
+  // grab latest operation's consensus timestamp for incremental sync
+  const latestOperationTimestamp =
+    !shouldSyncFromScratch && oldOperations[0]
+      ? new BigNumber(Math.floor(oldOperations[0].date.getTime() / 1000))
+      : null;
+  const latestAccountOperations = await getOperationsForAccount(
     liveAccountId,
     address,
     latestOperationTimestamp ? latestOperationTimestamp.toString() : null,
   );
-  const operations = mergeOps(oldOperations, newOperations);
+
+  const newSubAccounts = await getSubAccounts(
+    liveAccountId,
+    latestAccountOperations.tokenOperations,
+    mirrorTokens,
+  );
+  const subAccounts = mergeSubAccounts(initialAccount, newSubAccounts);
+  const newOperations = prepareOperations(
+    latestAccountOperations.coinOperations,
+    latestAccountOperations.tokenOperations,
+    mirrorTokens,
+  );
+  const enrichedNewOperations = applyPendingExtras(newOperations, pendingOperations);
+  const operations = shouldSyncFromScratch
+    ? enrichedNewOperations
+    : mergeOps(oldOperations, enrichedNewOperations);
 
   return {
     id: liveAccountId,
     freshAddress: address,
-    balance: accountBalance.balance,
-    spendableBalance: accountBalance.balance,
+    syncHash,
+    lastSyncDate: new Date(),
+    balance: new BigNumber(mirrorAccount.balance.balance),
+    spendableBalance: new BigNumber(mirrorAccount.balance.balance),
     operations,
     operationsCount: operations.length,
     // NOTE: there are no "blocks" in hedera
     // Set a value just so that operations are considered confirmed according to isConfirmedOperation
     blockHeight: 10,
+    subAccounts,
+    hederaResources: {
+      maxAutomaticTokenAssociations: mirrorAccount.max_automatic_token_associations,
+      isAutoTokenAssociationEnabled: mirrorAccount.max_automatic_token_associations === -1,
+    },
   };
 };
 
 export const buildIterateResult: IterateResultBuilder = async ({ result: rootResult }) => {
-  const accounts = await getAccountsForPublicKey(rootResult.publicKey);
-  const addresses = accounts.map(a => a.accountId.toString());
+  const mirrorAccounts = await getAccountsForPublicKey(rootResult.publicKey);
+  const addresses = mirrorAccounts.map(a => a.account);
 
   return async ({ currency, derivationMode, index }) => {
     const derivationScheme = getDerivationScheme({
@@ -72,6 +109,7 @@ export const buildIterateResult: IterateResultBuilder = async ({ result: rootRes
     const freshAddressPath = runDerivationScheme(derivationScheme, currency, {
       account: index,
     });
+
     return addresses[index]
       ? ({
           address: addresses[index],

package/src/bridge/transaction.test.ts

@@ -1,82 +1,40 @@
 import BigNumber from "bignumber.js";
-import type { Account } from "@ledgerhq/types-live";
-import type { Transaction, TransactionRaw } from "../types";
 import { formatTransaction, fromTransactionRaw, toTransactionRaw } from "../transaction";
-
-const account: Account = {
-  type: "Account",
-  id: "",
-  seedIdentifier: "",
-  derivationMode: "",
-  index: 0,
-  freshAddress: "",
-  freshAddressPath: "",
-  used: false,
-  balance: new BigNumber(200000),
-  spendableBalance: new BigNumber(0),
-  creationDate: new Date(),
-  blockHeight: 0,
-  currency: {
-    type: "CryptoCurrency",
-    id: "hedera",
-    managerAppName: "",
-    coinType: 0,
-    scheme: "",
-    color: "",
-    family: "",
-    explorerViews: [],
-    name: "",
-    ticker: "",
-    units: [
-      {
-        name: "",
-        code: "",
-        magnitude: 0,
-      },
-    ],
-  },
-  operationsCount: 0,
-  operations: [],
-  pendingOperations: [],
-  lastSyncDate: new Date(),
-  balanceHistoryCache: {
-    HOUR: { latestDate: null, balances: [] },
-    DAY: { latestDate: null, balances: [] },
-    WEEK: { latestDate: null, balances: [] },
-  },
-  swapHistory: [],
-};
-
-const transaction: Transaction = {
-  family: "hedera",
-  amount: new BigNumber(1),
-  recipient: "0.0.3",
-};
-
-const transactionRaw: TransactionRaw = {
-  family: "hedera",
-  amount: "1",
-  recipient: "0.0.3",
-};
+import { getMockedAccount } from "../test/fixtures/account.fixture";
+import {
+  getMockedTransaction,
+  getMockedTransactionRaw,
+} from "../test/fixtures/transaction.fixture";
 
 describe("transaction", () => {
+  const mockedAccount = getMockedAccount();
+  const mockedTransaction = getMockedTransaction({
+    amount: new BigNumber(100000000),
+    recipient: "0.0.3",
+  });
+  const mockedTransactionRaw = getMockedTransactionRaw({
+    amount: "100000000",
+    recipient: "0.0.3",
+  });
+
   test("formatTransaction", () => {
-    const result = formatTransaction(transaction, account);
-    const string = `SEND 1\nTO 0.0.3`;
+    const result = formatTransaction(mockedTransaction, mockedAccount);
+    const nonBreakingSpace = String.fromCharCode(160);
+    const string = `SEND 1${nonBreakingSpace}HBAR\nTO 0.0.3`;
 
     expect(result).toEqual(string);
   });
 
   test("fromTransactionRaw", () => {
-    const result = fromTransactionRaw(transactionRaw);
-    const data = transaction;
+    const result = fromTransactionRaw(mockedTransactionRaw);
+    const data = mockedTransaction;
 
     expect(result).toEqual(data);
   });
 
   test("toTransactionRaw", () => {
-    const result = toTransactionRaw(transaction);
-    const data = transactionRaw;
+    const result = toTransactionRaw(mockedTransaction);
+    const data = mockedTransactionRaw;
 
     expect(result).toEqual(data);
   });