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

package/src/bridge/buildOptimisticOperation.ts

@@ -1,21 +1,67 @@
-import { Account, Operation } from "@ledgerhq/types-live";
+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 } from "./utils";
-import { Transaction } from "../types";
+import { isTokenAssociateTransaction } from "../logic";
+import { HEDERA_OPERATION_TYPES } from "../constants";
 
-export const buildOptimisticOperation = async ({
+const buildOptimisticTokenAssociateOperation = async ({
+  account,
+  transaction,
+}: {
+  account: Account;
+  transaction: Transaction;
+}): Promise<Operation> => {
+  invariant(isTokenAssociateTransaction(transaction), "invalid transaction properties");
+
+  const estimatedFee = await getEstimatedFees(account, HEDERA_OPERATION_TYPES.TokenAssociate);
+  const value = transaction.amount;
+  const type: OperationType = "ASSOCIATE_TOKEN";
+
+  const operation: Operation = {
+    id: encodeOperationId(account.id, "", type),
+    hash: "",
+    type,
+    value,
+    fee: estimatedFee,
+    blockHash: null,
+    blockHeight: null,
+    senders: [account.freshAddress.toString()],
+    recipients: [transaction.recipient],
+    accountId: account.id,
+    date: new Date(),
+    extra: {
+      associatedTokenId: transaction.properties.token.contractAddress,
+    } satisfies HederaOperationExtra,
+  };
+
+  return operation;
+};
+
+const buildOptimisticCoinOperation = async ({
   account,
   transaction,
+  transactionType,
 }: {
   account: Account;
   transaction: Transaction;
+  transactionType?: OperationType;
 }): Promise<Operation> => {
+  const estimatedFee =
+    transactionType === "FEES"
+      ? transaction.amount
+      : await getEstimatedFees(account, HEDERA_OPERATION_TYPES.CryptoTransfer);
+  const value = transaction.amount;
+  const type: OperationType = transactionType ?? "OUT";
+
   const operation: Operation = {
-    id: encodeOperationId(account.id, "", "OUT"),
+    id: encodeOperationId(account.id, "", type),
     hash: "",
-    type: "OUT",
-    value: transaction.amount,
-    fee: await getEstimatedFees(account),
+    type,
+    value,
+    fee: estimatedFee,
     blockHash: null,
     blockHeight: null,
     senders: [account.freshAddress.toString()],
@@ -27,3 +73,68 @@ export const buildOptimisticOperation = async ({
 
   return operation;
 };
+
+const buildOptimisticTokenOperation = async ({
+  account,
+  tokenAccount,
+  transaction,
+}: {
+  account: Account;
+  tokenAccount: TokenAccount;
+  transaction: Transaction;
+}): Promise<Operation> => {
+  const estimatedFee = await getEstimatedFees(account, HEDERA_OPERATION_TYPES.TokenTransfer);
+  const value = transaction.amount;
+  const type: OperationType = "OUT";
+
+  const coinOperation = await buildOptimisticCoinOperation({
+    account,
+    transaction: {
+      ...transaction,
+      recipient: tokenAccount.token.contractAddress,
+      amount: estimatedFee,
+    },
+    transactionType: "FEES",
+  });
+
+  const operation: Operation = {
+    ...coinOperation,
+    subOperations: [
+      {
+        id: encodeOperationId(tokenAccount.id, "", type),
+        hash: "",
+        type,
+        value,
+        fee: estimatedFee,
+        blockHash: null,
+        blockHeight: null,
+        senders: [account.freshAddress.toString()],
+        recipients: [transaction.recipient],
+        accountId: tokenAccount.id,
+        date: new Date(),
+        extra: {},
+      },
+    ],
+  };
+
+  return operation;
+};
+
+export const buildOptimisticOperation = async ({
+  account,
+  transaction,
+}: {
+  account: Account;
+  transaction: Transaction;
+}): Promise<Operation> => {
+  const subAccount = findSubAccountById(account, transaction.subAccountId || "");
+  const isTokenTransaction = isTokenAccount(subAccount);
+
+  if (isTokenAssociateTransaction(transaction)) {
+    return buildOptimisticTokenAssociateOperation({ account, transaction });
+  } else if (isTokenTransaction) {
+    return buildOptimisticTokenOperation({ account, tokenAccount: subAccount, transaction });
+  } else {
+    return buildOptimisticCoinOperation({ account, transaction });
+  }
+};

package/src/bridge/estimateMaxSpendable.ts

@@ -1,18 +1,24 @@
 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";
 
 export const estimateMaxSpendable: AccountBridge<Transaction>["estimateMaxSpendable"] = async ({
   account,
   parentAccount,
 }) => {
+  const mainAccount = getMainAccount(account, parentAccount);
+  const isTokenTransaction = isTokenAccount(account);
   const balance = account.balance;
 
-  const mainAccount = getMainAccount(account, parentAccount);
-  const estimatedFees = await getEstimatedFees(mainAccount);
+  if (isTokenTransaction) {
+    return Promise.resolve(balance);
+  }
 
+  const estimatedFees = await getEstimatedFees(mainAccount, HEDERA_OPERATION_TYPES.CryptoTransfer);
   let maxSpendable = balance.minus(estimatedFees);
 
   // set max spendable to 0 if negative

package/src/bridge/getTransactionStatus.test.ts

@@ -0,0 +1,200 @@
+import BigNumber from "bignumber.js";
+import {
+  InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  AmountRequired,
+  NotEnoughBalance,
+  HederaInsufficientFundsForAssociation,
+  HederaRecipientTokenAssociationRequired,
+  HederaRecipientTokenAssociationUnverified,
+} from "@ledgerhq/errors";
+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);
+  const mockedUsdRate = new BigNumber(1);
+  const validRecipientAddress = "0.0.1234567";
+  const invalidRecipientAddress = "invalid_address";
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    jest.spyOn(utils, "getCurrencyToUSDRate").mockResolvedValueOnce(mockedUsdRate);
+    jest.spyOn(utils, "getEstimatedFees").mockResolvedValueOnce(mockedEstimatedFee);
+  });
+
+  test("coin transfer with valid recipient and sufficient balance completes successfully", async () => {
+    const mockedAccount = getMockedAccount({ balance: new BigNumber(1000) });
+    const mockedTransaction = getMockedTransaction({
+      recipient: validRecipientAddress,
+      amount: new BigNumber(100),
+    });
+
+    const result = await getTransactionStatus(mockedAccount, mockedTransaction);
+
+    expect(result.errors).toEqual({});
+    expect(result.warnings).toEqual({});
+    expect(result.amount).toEqual(new BigNumber(100));
+    expect(result.totalSpent.isGreaterThan(100)).toBe(true);
+  });
+
+  test("token transfer with valid recipient and sufficient balance completes successfully", async () => {
+    jest.spyOn(utils, "checkAccountTokenAssociationStatus").mockResolvedValueOnce(true);
+
+    const tokenCurrency = getMockedTokenCurrency();
+    const tokenAccount = getMockedTokenAccount(tokenCurrency, { balance: new BigNumber(500) });
+    const account = getMockedAccount({ balance: new BigNumber(1000), subAccounts: [tokenAccount] });
+    const transaction = getMockedTransaction({
+      subAccountId: tokenAccount.id,
+      recipient: validRecipientAddress,
+      amount: new BigNumber(200),
+    });
+
+    const result = await getTransactionStatus(account, transaction);
+
+    expect(result.errors).toEqual({});
+    expect(result.warnings).toEqual({});
+    expect(result.amount).toEqual(new BigNumber(200));
+  });
+
+  test("token associate transaction with sufficient USD worth completes successfully", async () => {
+    const mockedTokenCurrency = getMockedTokenCurrency();
+    const mockedAccount = getMockedAccount();
+    const mockedTransaction = getMockedTransaction({
+      properties: {
+        name: HEDERA_TRANSACTION_KINDS.TokenAssociate.name,
+        token: mockedTokenCurrency,
+      },
+    });
+
+    const result = await getTransactionStatus(mockedAccount, mockedTransaction);
+
+    expect(result.amount).toEqual(new BigNumber(0));
+    expect(result.errors).toEqual({});
+    expect(result.warnings).toEqual({});
+    expect(result.totalSpent).toEqual(mockedEstimatedFee);
+    expect(result.estimatedFees).toEqual(mockedEstimatedFee);
+  });
+
+  test("adds error for invalid recipient address", async () => {
+    const mockedAccount = getMockedAccount();
+    const mockedTransaction = getMockedTransaction({ recipient: invalidRecipientAddress });
+
+    const result = await getTransactionStatus(mockedAccount, mockedTransaction);
+
+    expect(result.errors.recipient).toBeInstanceOf(InvalidAddress);
+  });
+
+  test("adds error for self transfers", async () => {
+    const mockedAccount = getMockedAccount();
+    const mockedTransaction = getMockedTransaction({
+      recipient: mockedAccount.freshAddress,
+    });
+
+    const result = await getTransactionStatus(mockedAccount, mockedTransaction);
+
+    expect(result.errors.recipient).toBeInstanceOf(InvalidAddressBecauseDestinationIsAlsoSource);
+  });
+
+  test("adds error during coin transfer with insufficient balance", async () => {
+    const mockedAccount = getMockedAccount({ balance: new BigNumber(0) });
+    const mockedTransaction = getMockedTransaction({
+      amount: new BigNumber(100),
+      recipient: validRecipientAddress,
+    });
+
+    const result = await getTransactionStatus(mockedAccount, mockedTransaction);
+
+    expect(result.errors.amount).toBeInstanceOf(NotEnoughBalance);
+  });
+
+  test("adds error if USD balance is too low for token association", async () => {
+    const mockedTokenCurrency = getMockedTokenCurrency();
+    const mockedAccount = getMockedAccount({ balance: new BigNumber(0) });
+    const mockedTransaction = getMockedTransaction({
+      properties: {
+        name: HEDERA_TRANSACTION_KINDS.TokenAssociate.name,
+        token: mockedTokenCurrency,
+      },
+    });
+
+    const result = await getTransactionStatus(mockedAccount, mockedTransaction);
+
+    expect(result.errors.insufficientAssociateBalance).toBeInstanceOf(
+      HederaInsufficientFundsForAssociation,
+    );
+  });
+
+  test("adds warning during token transfer if recipient has no token associated", async () => {
+    jest.spyOn(utils, "checkAccountTokenAssociationStatus").mockResolvedValueOnce(false);
+
+    const mockedTokenCurrency = getMockedTokenCurrency();
+    const mockedTokenAccount = getMockedTokenAccount(mockedTokenCurrency);
+    const mockedAccount = getMockedAccount({ subAccounts: [mockedTokenAccount] });
+    const mockedTransaction = getMockedTransaction({
+      subAccountId: mockedTokenAccount.id,
+      recipient: validRecipientAddress,
+    });
+
+    const result = await getTransactionStatus(mockedAccount, mockedTransaction);
+
+    expect(result.warnings.missingAssociation).toBeInstanceOf(
+      HederaRecipientTokenAssociationRequired,
+    );
+  });
+
+  test("adds warning if token association status can't be verified", async () => {
+    jest
+      .spyOn(utils, "checkAccountTokenAssociationStatus")
+      .mockRejectedValueOnce(new HederaRecipientTokenAssociationUnverified());
+
+    const mockedTokenCurrency = getMockedTokenCurrency();
+    const mockedTokenAccount = getMockedTokenAccount(mockedTokenCurrency);
+    const mockedAccount = getMockedAccount({ subAccounts: [mockedTokenAccount] });
+    const mockedTransaction = getMockedTransaction({
+      subAccountId: mockedTokenAccount.id,
+      recipient: validRecipientAddress,
+    });
+
+    const result = await getTransactionStatus(mockedAccount, mockedTransaction);
+
+    expect(result.warnings.unverifiedAssociation).toBeInstanceOf(
+      HederaRecipientTokenAssociationUnverified,
+    );
+  });
+
+  test("adds error during token transfer with insufficient balance", async () => {
+    const mockedTokenCurrency = getMockedTokenCurrency();
+    const mockedTokenAccount = getMockedTokenAccount(mockedTokenCurrency, {
+      balance: new BigNumber(0),
+    });
+    const mockedAccount = getMockedAccount({ subAccounts: [mockedTokenAccount] });
+    const mockedTransaction = getMockedTransaction({
+      subAccountId: mockedTokenAccount.id,
+      recipient: validRecipientAddress,
+      amount: new BigNumber(100),
+    });
+
+    const result = await getTransactionStatus(mockedAccount, mockedTransaction);
+
+    expect(result.errors.amount).toBeInstanceOf(NotEnoughBalance);
+  });
+
+  test("adds error if amount is zero and useAllAmount is false", async () => {
+    const mockedAccount = getMockedAccount();
+    const mockedTransaction = getMockedTransaction({
+      recipient: validRecipientAddress,
+      amount: new BigNumber(0),
+      useAllAmount: false,
+    });
+
+    const result = await getTransactionStatus(mockedAccount, mockedTransaction);
+
+    expect(result.errors.amount).toBeInstanceOf(AmountRequired);
+  });
+});

package/src/bridge/getTransactionStatus.ts

@@ -1,55 +1,189 @@
+import BigNumber from "bignumber.js";
+import { AccountId } from "@hashgraph/sdk";
 import {
   AmountRequired,
   NotEnoughBalance,
   InvalidAddress,
   InvalidAddressBecauseDestinationIsAlsoSource,
   RecipientRequired,
+  HederaInsufficientFundsForAssociation,
+  HederaRecipientTokenAssociationRequired,
+  HederaRecipientTokenAssociationUnverified,
 } from "@ledgerhq/errors";
-import { AccountId } from "@hashgraph/sdk";
-import type { AccountBridge } from "@ledgerhq/types-live";
-import { calculateAmount, getEstimatedFees } from "./utils";
-import type { Transaction } from "../types";
-
-export const getTransactionStatus: AccountBridge<Transaction>["getTransactionStatus"] = async (
-  account,
-  transaction,
-) => {
-  const errors: Record<string, Error> = {};
-
-  if (!transaction.recipient || transaction.recipient.length === 0) {
-    errors.recipient = new RecipientRequired("");
-  } else {
-    if (account.freshAddress === transaction.recipient) {
-      errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource("");
+import type { Account, AccountBridge, TokenAccount } from "@ledgerhq/types-live";
+import { findSubAccountById, isTokenAccount } from "@ledgerhq/coin-framework/account";
+import { getEnv } from "@ledgerhq/live-env";
+import { isTokenAssociateTransaction, isTokenAssociationRequired } from "../logic";
+import type { TokenAssociateProperties, Transaction, TransactionStatus } from "../types";
+import {
+  calculateAmount,
+  checkAccountTokenAssociationStatus,
+  getCurrencyToUSDRate,
+  getEstimatedFees,
+} from "./utils";
+import { HEDERA_OPERATION_TYPES } from "../constants";
+
+type Errors = Record<string, Error>;
+type Warnings = Record<string, Error>;
+
+function validateRecipient(account: Account, recipient: string): Error | null {
+  if (!recipient || recipient.length === 0) {
+    return new RecipientRequired();
+  }
+
+  if (account.freshAddress === recipient) {
+    return new InvalidAddressBecauseDestinationIsAlsoSource();
+  }
+
+  try {
+    AccountId.fromString(recipient);
+  } catch (err) {
+    return new InvalidAddress("", {
+      currencyName: account.currency.name,
+    });
+  }
+
+  return null;
+}
+
+async function handleTokenAssociateTransaction(
+  account: Account,
+  transaction: Extract<Required<Transaction>, { properties: TokenAssociateProperties }>,
+): Promise<TransactionStatus> {
+  const errors: Errors = {};
+  const warnings: Warnings = {};
+
+  const [usdRate, estimatedFees] = await Promise.all([
+    getCurrencyToUSDRate(account.currency),
+    getEstimatedFees(account, HEDERA_OPERATION_TYPES.TokenAssociate),
+  ]);
+
+  const amount = BigNumber(0);
+  const totalSpent = amount.plus(estimatedFees);
+  const isAssociationFlow = isTokenAssociationRequired(account, transaction.properties.token);
+
+  if (isAssociationFlow) {
+    const hbarBalance = account.balance.dividedBy(10 ** account.currency.units[0].magnitude);
+    const currentWorthInUSD = usdRate ? hbarBalance.multipliedBy(usdRate) : new BigNumber(0);
+    const requiredWorthInUSD = getEnv("HEDERA_TOKEN_ASSOCIATION_MIN_USD");
+
+    if (currentWorthInUSD.isLessThan(requiredWorthInUSD)) {
+      errors.insufficientAssociateBalance = new HederaInsufficientFundsForAssociation("", {
+        requiredWorthInUSD,
+      });
     }
+  }
+
+  return {
+    amount,
+    totalSpent,
+    estimatedFees,
+    errors,
+    warnings,
+  };
+}
+
+async function handleTokenTransaction(
+  account: Account,
+  subAccount: TokenAccount,
+  transaction: Transaction,
+): Promise<TransactionStatus> {
+  const errors: Errors = {};
+  const warnings: Warnings = {};
+  const [calculatedAmount, estimatedFees] = await Promise.all([
+    calculateAmount({ transaction, account }),
+    getEstimatedFees(account, HEDERA_OPERATION_TYPES.TokenTransfer),
+  ]);
+
+  const recipientError = validateRecipient(account, transaction.recipient);
+
+  if (recipientError) {
+    errors.recipient = recipientError;
+  }
 
+  if (!errors.recipient) {
     try {
-      AccountId.fromString(transaction.recipient);
-    } catch (err) {
-      errors.recipient = new InvalidAddress("", {
-        currencyName: account.currency.name,
-      });
+      const hasRecipientTokenAssociated = await checkAccountTokenAssociationStatus(
+        transaction.recipient,
+        subAccount.token.contractAddress,
+      );
+
+      if (!hasRecipientTokenAssociated) {
+        warnings.missingAssociation = new HederaRecipientTokenAssociationRequired();
+      }
+    } catch {
+      warnings.unverifiedAssociation = new HederaRecipientTokenAssociationUnverified();
     }
   }
 
-  const { amount, totalSpent } = await calculateAmount({
-    transaction,
-    account,
-  });
+  if (transaction.amount.eq(0)) {
+    errors.amount = new AmountRequired();
+  }
+
+  if (subAccount.balance.isLessThan(calculatedAmount.totalSpent)) {
+    errors.amount = new NotEnoughBalance();
+  }
+
+  if (account.balance.isLessThan(estimatedFees)) {
+    errors.amount = new NotEnoughBalance();
+  }
+
+  return {
+    amount: calculatedAmount.amount,
+    totalSpent: calculatedAmount.totalSpent,
+    estimatedFees,
+    errors,
+    warnings,
+  };
+}
+
+async function handleCoinTransaction(
+  account: Account,
+  transaction: Transaction,
+): Promise<TransactionStatus> {
+  const errors: Errors = {};
+  const warnings: Warnings = {};
+  const [calculatedAmount, estimatedFees] = await Promise.all([
+    calculateAmount({ transaction, account }),
+    getEstimatedFees(account, HEDERA_OPERATION_TYPES.CryptoTransfer),
+  ]);
+
+  const recipientError = validateRecipient(account, transaction.recipient);
+
+  if (recipientError) {
+    errors.recipient = recipientError;
+  }
 
   if (transaction.amount.eq(0) && !transaction.useAllAmount) {
     errors.amount = new AmountRequired();
-  } else if (account.balance.isLessThan(totalSpent)) {
-    errors.amount = new NotEnoughBalance("");
   }
 
-  const estimatedFees = await getEstimatedFees(account);
+  if (account.balance.isLessThan(calculatedAmount.totalSpent)) {
+    errors.amount = new NotEnoughBalance("");
+  }
 
   return {
-    amount,
-    errors,
+    amount: calculatedAmount.amount,
+    totalSpent: calculatedAmount.totalSpent,
     estimatedFees,
-    totalSpent,
-    warnings: {},
+    errors,
+    warnings,
   };
+}
+
+export const getTransactionStatus: AccountBridge<
+  Transaction,
+  Account,
+  TransactionStatus
+>["getTransactionStatus"] = async (account, transaction) => {
+  const subAccount = findSubAccountById(account, transaction?.subAccountId || "");
+  const isTokenTransaction = isTokenAccount(subAccount);
+
+  if (isTokenAssociateTransaction(transaction)) {
+    return handleTokenAssociateTransaction(account, transaction);
+  } else if (isTokenTransaction) {
+    return handleTokenTransaction(account, subAccount, transaction);
+  } else {
+    return handleCoinTransaction(account, transaction);
+  }
 };

package/src/bridge/index.ts

@@ -4,19 +4,20 @@ import {
   makeSync,
   updateTransaction,
 } from "@ledgerhq/coin-framework/bridge/jsHelpers";
-import resolver from "../signer/index";
 import getAddressWrapper from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
-import { SignerContext } from "@ledgerhq/coin-framework/signer";
-import type { Account, AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
-import type { Transaction, TransactionStatus, HederaSigner } from "../types";
-import { getTransactionStatus } from "./getTransactionStatus";
+import type { SignerContext } from "@ledgerhq/coin-framework/signer";
+import type { AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
+import { broadcast } from "./broadcast";
+import { createTransaction } from "./createTransaction";
 import { estimateMaxSpendable } from "./estimateMaxSpendable";
+import { getTransactionStatus } from "./getTransactionStatus";
 import { prepareTransaction } from "./prepareTransaction";
-import { createTransaction } from "./createTransaction";
-import { getAccountShape, buildIterateResult } from "./synchronisation";
-import { buildSignOperation } from "./signOperation";
-import { broadcast } from "./broadcast";
 import { receive } from "./receive";
+import { buildSignOperation } from "./signOperation";
+import { getAccountShape, buildIterateResult } from "./synchronisation";
+import { assignFromAccountRaw, assignToAccountRaw } from "./serialization";
+import resolver from "../signer/index";
+import type { Transaction, TransactionStatus, HederaSigner, HederaAccount } from "../types";
 
 function buildCurrencyBridge(signerContext: SignerContext<HederaSigner>): CurrencyBridge {
   const getAddress = resolver(signerContext);
@@ -38,7 +39,7 @@ const sync = makeSync({ getAccountShape });
 
 function buildAccountBridge(
   signerContext: SignerContext<HederaSigner>,
-): AccountBridge<Transaction, Account, TransactionStatus> {
+): AccountBridge<Transaction, HederaAccount, TransactionStatus> {
   const getAddress = resolver(signerContext);
 
   const signOperation = buildSignOperation(signerContext);
@@ -49,6 +50,8 @@ function buildAccountBridge(
     updateTransaction,
     getTransactionStatus,
     prepareTransaction,
+    assignToAccountRaw,
+    assignFromAccountRaw,
     sync,
     receive: receive(getAddressWrapper(getAddress)),
     signOperation,