@ledgerhq/coin-hedera 1.10.1 → 1.11.0-nightly.2

package/src/logic.test.ts

@@ -1,62 +1,152 @@
-import { BigNumber } from "bignumber.js";
-import { Operation } from "@ledgerhq/types-live";
 import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
-import { getTransactionExplorer } from "./logic";
-
-describe("getTransactionExplorer", () => {
-  test("Tx explorer URL is converted from hash to consensus timestamp", async () => {
-    const explorerView = getCryptoCurrencyById("hedera").explorerViews[0];
-    expect(explorerView).toEqual({
-      tx: expect.any(String),
-      address: expect.any(String),
-    });
-
-    const mockOperation: Operation = {
-      extra: {
-        consensusTimestamp: "1.2.3.4",
-      },
-      id: "",
-      hash: "",
-      type: "IN",
-      value: new BigNumber(0),
-      fee: new BigNumber(0),
-      senders: [],
-      recipients: [],
-      blockHeight: undefined,
-      blockHash: undefined,
-      accountId: "",
-      date: new Date(),
-    };
-
-    const newUrl = getTransactionExplorer(explorerView, mockOperation);
-    expect(newUrl).toBe("https://hashscan.io/mainnet/transaction/1.2.3.4");
+import {
+  getTransactionExplorer,
+  isAutoTokenAssociationEnabled,
+  isTokenAssociateTransaction,
+  isTokenAssociationRequired,
+  isValidExtra,
+  sendRecipientCanNext,
+} from "./logic";
+import { getMockedAccount, getMockedTokenAccount } from "./test/fixtures/account.fixture";
+import { getMockedOperation } from "./test/fixtures/operation.fixture";
+import { getMockedTokenCurrency } from "./test/fixtures/currency.fixture";
+import { HEDERA_TRANSACTION_KINDS } from "./constants";
+
+describe("logic", () => {
+  describe("getTransactionExplorer", () => {
+    test("Tx explorer URL is converted from hash to consensus timestamp", async () => {
+      const explorerView = getCryptoCurrencyById("hedera").explorerViews[0];
+      expect(explorerView).toEqual({
+        tx: expect.any(String),
+        address: expect.any(String),
+      });
+
+      const mockedOperation = getMockedOperation({
+        extra: { consensusTimestamp: "1.2.3.4" },
+      });
+
+      const newUrl = getTransactionExplorer(explorerView, mockedOperation);
+      expect(newUrl).toBe("https://hashscan.io/mainnet/transaction/1.2.3.4");
+    });
+
+    test("Tx explorer URL is based on transaction id if consensus timestamp is not available", async () => {
+      const explorerView = getCryptoCurrencyById("hedera").explorerViews[0];
+      expect(explorerView).toEqual({
+        tx: expect.any(String),
+        address: expect.any(String),
+      });
+
+      const mockedOperation = getMockedOperation({
+        extra: { transactionId: "0.0.1234567-123-123" },
+      });
+
+      const newUrl = getTransactionExplorer(explorerView, mockedOperation);
+      expect(newUrl).toBe("https://hashscan.io/mainnet/transaction/0.0.1234567-123-123");
+    });
+  });
+
+  describe("isTokenAssociateTransaction", () => {
+    test("returns correct value based on tx.properties", () => {
+      expect(
+        isTokenAssociateTransaction({
+          properties: { name: HEDERA_TRANSACTION_KINDS.TokenAssociate.name },
+        } as any),
+      ).toBe(true);
+
+      expect(
+        isTokenAssociateTransaction({
+          properties: { name: "transfer" },
+        } as any),
+      ).toBe(false);
+
+      expect(isTokenAssociateTransaction({} as any)).toBe(false);
+    });
+  });
+
+  describe("isAutoTokenAssociationEnabled", () => {
+    test("returns value based on isAutoTokenAssociationEnabled flag", () => {
+      expect(
+        isAutoTokenAssociationEnabled({
+          hederaResources: { isAutoTokenAssociationEnabled: true },
+        } as any),
+      ).toBe(true);
+
+      expect(
+        isAutoTokenAssociationEnabled({
+          hederaResources: { isAutoTokenAssociationEnabled: false },
+        } as any),
+      ).toBe(false);
+
+      expect(isAutoTokenAssociationEnabled({} as any)).toBe(false);
+    });
   });
 
-  test("Tx explorer URL is based on transaction id if consensus timestamp is not available", async () => {
-    const explorerView = getCryptoCurrencyById("hedera").explorerViews[0];
-    expect(explorerView).toEqual({
-      tx: expect.any(String),
-      address: expect.any(String),
-    });
-
-    const mockOperation: Operation = {
-      extra: {
-        transactionId: "0.0.1234567-123-123",
-      },
-      id: "",
-      hash: "",
-      type: "IN",
-      value: new BigNumber(0),
-      fee: new BigNumber(0),
-      senders: [],
-      recipients: [],
-      blockHeight: undefined,
-      blockHash: undefined,
-      accountId: "",
-      date: new Date(),
-    };
-
-    const newUrl = getTransactionExplorer(explorerView, mockOperation);
-    expect(newUrl).toBe("https://hashscan.io/mainnet/transaction/0.0.1234567-123-123");
+  describe("isTokenAssociationRequired", () => {
+    test("should return false if token is already associated (token account exists)", () => {
+      const mockedTokenCurrency = getMockedTokenCurrency();
+      const mockedTokenAccount = getMockedTokenAccount(mockedTokenCurrency);
+      const mockedAccount = getMockedAccount({ subAccounts: [mockedTokenAccount] });
+
+      expect(isTokenAssociationRequired(mockedAccount, mockedTokenCurrency)).toBe(false);
+    });
+
+    test("should return false if auto token associations are enabled", () => {
+      const mockedTokenCurrency = getMockedTokenCurrency();
+      const mockedAccount = getMockedAccount({
+        subAccounts: [],
+        hederaResources: {
+          maxAutomaticTokenAssociations: -1,
+          isAutoTokenAssociationEnabled: true,
+        },
+      });
+
+      expect(isTokenAssociationRequired(mockedAccount, mockedTokenCurrency)).toBe(false);
+    });
+
+    test("should return true if token is not associated and auto associations are disabled", () => {
+      const mockedTokenCurrency = getMockedTokenCurrency();
+      const mockedAccount = getMockedAccount({ subAccounts: [] });
+
+      expect(isTokenAssociationRequired(mockedAccount, mockedTokenCurrency)).toBe(true);
+    });
+
+    test("should return false if token is undefined", () => {
+      const mockedAccount = getMockedAccount({ subAccounts: [] });
+
+      expect(isTokenAssociationRequired(mockedAccount, undefined)).toBe(false);
+    });
+
+    test("should return false for legacy accounts without subAccounts or hederaResources", () => {
+      const mockedTokenCurrency = getMockedTokenCurrency();
+      const mockedAccount = getMockedAccount();
+
+      delete mockedAccount.subAccounts;
+      delete mockedAccount.hederaResources;
+
+      expect(isTokenAssociationRequired(mockedAccount, mockedTokenCurrency)).toBe(true);
+    });
+  });
+
+  describe("isValidExtra", () => {
+    test("returns true for object and false for invalid types", () => {
+      expect(isValidExtra({ some: "value" })).toBe(true);
+      expect(isValidExtra(null)).toBe(false);
+      expect(isValidExtra(undefined)).toBe(false);
+      expect(isValidExtra("string")).toBe(false);
+      expect(isValidExtra(123)).toBe(false);
+      expect(isValidExtra([])).toBe(false);
+    });
+  });
+
+  describe("sendRecipientCanNext", () => {
+    test("handles association warnings", () => {
+      expect(sendRecipientCanNext({ warnings: {} } as any)).toBe(true);
+      expect(sendRecipientCanNext({ warnings: { missingAssociation: new Error() } } as any)).toBe(
+        false,
+      );
+      expect(
+        sendRecipientCanNext({ warnings: { unverifiedAssociation: new Error() } } as any),
+      ).toBe(false);
+    });
   });
 });

package/src/logic.ts

@@ -1,15 +1,66 @@
-import { ExplorerView } from "@ledgerhq/types-cryptoassets";
-import { Operation } from "@ledgerhq/types-live";
-
-import { HederaOperationExtra } from "./types";
+import type { ExplorerView, TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import type { AccountLike, Operation } from "@ledgerhq/types-live";
+import { HEDERA_TRANSACTION_KINDS } from "./constants";
+import type {
+  HederaAccount,
+  HederaOperationExtra,
+  TokenAssociateProperties,
+  Transaction,
+  TransactionStatus,
+} from "./types";
 
 const getTransactionExplorer = (
   explorerView: ExplorerView | null | undefined,
   operation: Operation,
 ): string | undefined => {
-  const extra = operation.extra as HederaOperationExtra;
+  const extra = isValidExtra(operation.extra) ? operation.extra : null;
+
+  return explorerView?.tx?.replace(
+    "$hash",
+    extra?.consensusTimestamp ?? extra?.transactionId ?? "0",
+  );
+};
+
+const isTokenAssociateTransaction = (
+  tx: Transaction,
+): tx is Extract<Required<Transaction>, { properties: TokenAssociateProperties }> => {
+  return tx.properties?.name === HEDERA_TRANSACTION_KINDS.TokenAssociate.name;
+};
+
+const isAutoTokenAssociationEnabled = (account: AccountLike) => {
+  const hederaAccount = "hederaResources" in account ? (account as HederaAccount) : null;
 
-  return explorerView?.tx?.replace("$hash", extra.consensusTimestamp ?? extra.transactionId ?? "0");
+  return hederaAccount?.hederaResources?.isAutoTokenAssociationEnabled ?? false;
 };
 
-export { getTransactionExplorer };
+const isTokenAssociationRequired = (
+  account: AccountLike,
+  token: TokenCurrency | null | undefined,
+) => {
+  const subAccounts = !!account && "subAccounts" in account ? account.subAccounts ?? [] : [];
+  const isTokenAssociated = subAccounts.some(item => item.token.id === token?.id);
+
+  return !!token && !isTokenAssociated && !isAutoTokenAssociationEnabled(account);
+};
+
+const isValidExtra = (extra: unknown): extra is HederaOperationExtra => {
+  return !!extra && typeof extra === "object" && !Array.isArray(extra);
+};
+
+// disables the "Continue" button in the Send modal's Recipient step during token transfers if:
+// - the recipient is not associated with the token
+// - the association status can't be verified
+const sendRecipientCanNext = (status: TransactionStatus) => {
+  const { missingAssociation, unverifiedAssociation } = status.warnings;
+
+  return !missingAssociation && !unverifiedAssociation;
+};
+
+export {
+  sendRecipientCanNext,
+  getTransactionExplorer,
+  isValidExtra,
+  isTokenAssociateTransaction,
+  isTokenAssociationRequired,
+  isAutoTokenAssociationEnabled,
+};

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

@@ -0,0 +1,123 @@
+import BigNumber from "bignumber.js";
+import type {
+  HederaAccount,
+  HederaAccountRaw,
+  HederaResources,
+  HederaResourcesRaw,
+} from "../../types";
+import type { TokenAccount } from "@ledgerhq/types-live";
+import { getMockedCurrency, getMockedTokenCurrency } from "./currency.fixture";
+import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
+
+const defaultMockedCurrency = getMockedCurrency();
+const defaultMockedTokenCurrency = getMockedTokenCurrency();
+const defaultMockAccountId = "js:2:hedera:0.0.1234567:hederaBip44";
+const defaultMockTokenAccountId = `${defaultMockAccountId}+${defaultMockedTokenCurrency.id}`;
+const defaultBalance = new BigNumber(100000000);
+const defaultTokenBalance = new BigNumber(10);
+
+export const mockHederaResources: HederaResources = {
+  maxAutomaticTokenAssociations: 0,
+  isAutoTokenAssociationEnabled: false,
+};
+
+export const mockHederaResourcesRaw: HederaResourcesRaw = {
+  maxAutomaticTokenAssociations: 0,
+  isAutoTokenAssociationEnabled: false,
+};
+
+/**
+ * default settings:
+ * - account balance is 1 HBAR
+ * - auto token association is disabled
+ * - subAccounts array is empty (no tokens account are used)
+ */
+export const getMockedAccount = (overrides?: Partial<HederaAccount>): HederaAccount => {
+  return {
+    type: "Account",
+    id: defaultMockAccountId,
+    seedIdentifier: "",
+    derivationMode: "",
+    index: 0,
+    freshAddress: "0.0.12345",
+    freshAddressPath: "44/3030",
+    used: false,
+    balance: defaultBalance,
+    spendableBalance: defaultBalance,
+    creationDate: new Date(),
+    blockHeight: 0,
+    currency: defaultMockedCurrency,
+    operationsCount: 0,
+    operations: [],
+    pendingOperations: [],
+    lastSyncDate: new Date(),
+    balanceHistoryCache: {
+      HOUR: { latestDate: null, balances: [] },
+      DAY: { latestDate: null, balances: [] },
+      WEEK: { latestDate: null, balances: [] },
+    },
+    swapHistory: [],
+    subAccounts: [],
+    hederaResources: mockHederaResources,
+    ...overrides,
+  };
+};
+
+export const getMockedAccountRaw = (overrides?: Partial<HederaAccountRaw>): HederaAccountRaw => {
+  return {
+    id: defaultMockAccountId,
+    seedIdentifier: "",
+    derivationMode: "",
+    index: 0,
+    freshAddress: "0.0.12345",
+    freshAddressPath: "44/3030",
+    used: false,
+    balance: defaultBalance.toString(),
+    spendableBalance: defaultBalance.toString(),
+    creationDate: new Date().toISOString(),
+    blockHeight: 0,
+    currencyId: defaultMockedCurrency.id,
+    operationsCount: 0,
+    operations: [],
+    pendingOperations: [],
+    lastSyncDate: new Date().toISOString(),
+    balanceHistoryCache: {
+      HOUR: { latestDate: null, balances: [] },
+      DAY: { latestDate: null, balances: [] },
+      WEEK: { latestDate: null, balances: [] },
+    },
+    swapHistory: [],
+    subAccounts: [],
+    hederaResources: mockHederaResourcesRaw,
+    ...overrides,
+  };
+};
+
+/**
+ * default settings:
+ * - balance is 10
+ */
+export const getMockedTokenAccount = (
+  token: TokenCurrency,
+  overrides?: Partial<TokenAccount>,
+): TokenAccount => {
+  return {
+    type: "TokenAccount",
+    id: defaultMockTokenAccountId,
+    parentId: defaultMockAccountId,
+    token,
+    balance: defaultTokenBalance,
+    spendableBalance: defaultTokenBalance,
+    creationDate: new Date(),
+    operations: [],
+    operationsCount: 0,
+    pendingOperations: [],
+    swapHistory: [],
+    balanceHistoryCache: {
+      HOUR: { latestDate: null, balances: [] },
+      DAY: { latestDate: null, balances: [] },
+      WEEK: { latestDate: null, balances: [] },
+    },
+    ...overrides,
+  };
+};

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

@@ -0,0 +1,66 @@
+import { getCryptoCurrencyById, listTokensForCryptoCurrency } from "@ledgerhq/cryptoassets";
+import type { CryptoCurrency, TokenCurrency } from "@ledgerhq/types-cryptoassets";
+import invariant from "invariant";
+
+export const getMockedCurrency = (overrides?: Partial<CryptoCurrency>): CryptoCurrency => {
+  return {
+    type: "CryptoCurrency",
+    id: "hedera",
+    managerAppName: "Hedera",
+    coinType: 3030,
+    scheme: "hedera",
+    color: "#000",
+    family: "hedera",
+    explorerViews: [
+      {
+        tx: "https://hashscan.io/mainnet/transaction/$hash",
+        address: "https://hashscan.io/mainnet/account/$address",
+      },
+    ],
+    name: "Hedera",
+    ticker: "HBAR",
+    units: [
+      {
+        name: "HBAR",
+        code: "HBAR",
+        magnitude: 8,
+      },
+    ],
+    ...overrides,
+  };
+};
+
+export const getTokenCurrencyFromCAL = (
+  index: number,
+  overrides?: Partial<TokenCurrency>,
+): TokenCurrency => {
+  const hedera = getCryptoCurrencyById("hedera");
+  const token = listTokensForCryptoCurrency(hedera)[index];
+
+  invariant(token, `token not found in CAL list on ${index} position`);
+
+  return {
+    ...token,
+    ...overrides,
+  };
+};
+
+export const getMockedTokenCurrency = (overrides?: Partial<TokenCurrency>): TokenCurrency => {
+  return {
+    id: "hedera/hts/test_0.0.1234567",
+    contractAddress: "0.0.1001",
+    parentCurrency: getMockedCurrency(),
+    tokenType: "hts",
+    name: "Test token",
+    ticker: "TEST",
+    type: "TokenCurrency",
+    units: [
+      {
+        name: "Test",
+        code: "TEST",
+        magnitude: 8,
+      },
+    ],
+    ...overrides,
+  };
+};

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

@@ -0,0 +1,14 @@
+import { HederaMirrorToken } from "../../api/types";
+
+export const getMockedMirrorToken = (overrides?: Partial<HederaMirrorToken>): HederaMirrorToken => {
+  return {
+    token_id: "",
+    created_timestamp: "123",
+    automatic_association: false,
+    balance: 0,
+    decimals: 0,
+    freeze_status: "NOT_APPLICABLE",
+    kyc_status: "NOT_APPLICABLE",
+    ...overrides,
+  };
+};

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

@@ -0,0 +1,20 @@
+import BigNumber from "bignumber.js";
+import type { HederaOperation } from "../../types";
+
+export const getMockedOperation = (overrides?: Partial<HederaOperation>): HederaOperation => {
+  return {
+    id: "",
+    hash: "",
+    type: "IN",
+    value: new BigNumber(0),
+    fee: new BigNumber(0),
+    senders: [],
+    recipients: [],
+    blockHeight: undefined,
+    blockHash: undefined,
+    accountId: "",
+    date: new Date(),
+    extra: {},
+    ...overrides,
+  };
+};

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

@@ -0,0 +1,22 @@
+import BigNumber from "bignumber.js";
+import type { Transaction, TransactionRaw } from "../../types";
+
+export const getMockedTransaction = (overrides?: Partial<Transaction>): Transaction => {
+  return {
+    family: "hedera",
+    amount: new BigNumber(0),
+    recipient: "",
+    useAllAmount: false,
+    ...overrides,
+  };
+};
+
+export const getMockedTransactionRaw = (overrides?: Partial<TransactionRaw>): TransactionRaw => {
+  return {
+    family: "hedera",
+    amount: "0",
+    recipient: "",
+    useAllAmount: false,
+    ...overrides,
+  };
+};

package/src/types/bridge.ts

@@ -1,9 +1,14 @@
+import { TokenCurrency } from "@ledgerhq/types-cryptoassets";
 import type {
+  Account,
+  AccountRaw,
+  Operation,
   TransactionCommon,
   TransactionCommonRaw,
   TransactionStatusCommon,
   TransactionStatusCommonRaw,
 } from "@ledgerhq/types-live";
+import { HEDERA_TRANSACTION_KINDS } from "../constants";
 
 export type NetworkInfo = {
   family: "hedera";
@@ -13,21 +18,49 @@ export type NetworkInfoRaw = {
   family: "hedera";
 };
 
+export type TokenAssociateProperties = {
+  name: typeof HEDERA_TRANSACTION_KINDS.TokenAssociate.name;
+  token: TokenCurrency;
+};
+
 export type Transaction = TransactionCommon & {
   family: "hedera";
   memo?: string | undefined;
+  properties?: TokenAssociateProperties;
 };
 
 export type TransactionRaw = TransactionCommonRaw & {
   family: "hedera";
   memo?: string | undefined;
+  properties?: TokenAssociateProperties;
 };
 
 export type TransactionStatus = TransactionStatusCommon;
 
 export type TransactionStatusRaw = TransactionStatusCommonRaw;
 
+export interface HederaResources {
+  maxAutomaticTokenAssociations: number;
+  isAutoTokenAssociationEnabled: boolean;
+}
+
+export interface HederaResourcesRaw {
+  maxAutomaticTokenAssociations: number;
+  isAutoTokenAssociationEnabled: boolean;
+}
+
+export type HederaAccount = Account & {
+  hederaResources?: HederaResources;
+};
+
+export type HederaAccountRaw = AccountRaw & {
+  hederaResources?: HederaResourcesRaw;
+};
+
 export type HederaOperationExtra = {
   consensusTimestamp?: string;
   transactionId?: string;
+  associatedTokenId?: string;
 };
+
+export type HederaOperation = Operation<HederaOperationExtra>;