@ledgerhq/coin-hedera 1.12.1-nightly.1 → 1.13.0-nightly.3

package/src/api/mirror.ts

@@ -1,91 +0,0 @@
-import network from "@ledgerhq/live-network/network";
-import { getEnv } from "@ledgerhq/live-env";
-import type { HederaMirrorAccount, HederaMirrorToken, HederaMirrorTransaction } from "./types";
-import { HederaAddAccountError } from "../errors";
-import { LedgerAPI4xx } from "@ledgerhq/errors";
-
-const getMirrorApiUrl = (): string => getEnv("API_HEDERA_MIRROR");
-
-const fetch = (path: string) => {
-  return network({
-    method: "GET",
-    url: `${getMirrorApiUrl()}${path}`,
-  });
-};
-
-export async function getAccountsForPublicKey(publicKey: string): Promise<HederaMirrorAccount[]> {
-  let r;
-  try {
-    r = await fetch(`/api/v1/accounts?account.publicKey=${publicKey}&balance=true&limit=100`);
-  } catch (e: any) {
-    if (e.name === "LedgerAPI4xx") return [];
-    throw e;
-  }
-
-  const accounts = r.data.accounts as HederaMirrorAccount[];
-
-  return accounts;
-}
-
-export async function getAccount(address: string): Promise<HederaMirrorAccount> {
-  try {
-    const res = await fetch(`/api/v1/accounts/${address}`);
-    const account = res.data as HederaMirrorAccount;
-
-    return account;
-  } catch (error) {
-    if (error instanceof LedgerAPI4xx && "status" in error && error.status === 404) {
-      throw new HederaAddAccountError();
-    }
-
-    throw error;
-  }
-}
-
-export async function getAccountTransactions(
-  address: string,
-  since: string | null,
-): Promise<HederaMirrorTransaction[]> {
-  const transactions: HederaMirrorTransaction[] = [];
-  const params = new URLSearchParams({
-    "account.id": address,
-    order: "desc",
-    limit: "100",
-  });
-
-  if (since) {
-    params.append("timestamp", `gt:${since}`);
-  }
-
-  let nextUrl = `/api/v1/transactions?${params.toString()}`;
-
-  // WARNING: don't break the loop when `transactions` array is empty but `links.next` is present
-  // the mirror node API enforces a 60-day max time range per query, even if `timestamp` param is set
-  // see: https://hedera.com/blog/changes-to-the-hedera-operated-mirror-node
-  while (nextUrl) {
-    const res = await fetch(nextUrl);
-    const newTransactions = res.data.transactions as HederaMirrorTransaction[];
-    transactions.push(...newTransactions);
-    nextUrl = res.data.links.next;
-  }
-
-  return transactions;
-}
-
-export async function getAccountTokens(address: string): Promise<HederaMirrorToken[]> {
-  const tokens: HederaMirrorToken[] = [];
-  const params = new URLSearchParams({
-    limit: "100",
-  });
-
-  let nextUrl = `/api/v1/accounts/${address}/tokens?${params.toString()}`;
-
-  while (nextUrl) {
-    const res = await fetch(nextUrl);
-    const newTokens = res.data.tokens as HederaMirrorToken[];
-    tokens.push(...newTokens);
-    nextUrl = res.data.links.next;
-  }
-
-  return tokens;
-}

package/src/api/network.test.ts

@@ -1,49 +0,0 @@
-import BigNumber from "bignumber.js";
-import { TransferTransaction } from "@hashgraph/sdk";
-import type { Account } from "@ledgerhq/types-live";
-import { buildUnsignedTransaction } from "./network";
-import { Transaction } from "../types";
-import invariant from "invariant";
-
-describe("buildUnsignedTransaction", () => {
-  const mockAccount = {
-    freshAddress: "0.0.123",
-    id: "hedera:0:0.0.123",
-    balance: new BigNumber(1000),
-  } as Account;
-
-  test("builds basic transaction without maxFee", async () => {
-    const transaction: Transaction = {
-      family: "hedera",
-      amount: new BigNumber(100),
-      recipient: "0.0.456",
-      memo: "test memo",
-    };
-
-    const result = await buildUnsignedTransaction({ account: mockAccount, transaction });
-
-    expect(result).toBeInstanceOf(TransferTransaction);
-    invariant(result instanceof TransferTransaction, "hedera: TransferTransaction type guard");
-    expect(result.transactionMemo).toBe("test memo");
-    expect(result.isFrozen()).toBe(true);
-    expect(result.hbarTransfers.size).toBe(2);
-
-    const senderTransfer = result.hbarTransfers.get("0.0.123");
-    const recipientTransfer = result.hbarTransfers.get("0.0.456");
-
-    expect(senderTransfer?.toTinybars().toNumber()).toBe(-100);
-    expect(recipientTransfer?.toTinybars().toNumber()).toBe(100);
-  });
-
-  test("sets max transaction fee when provided", async () => {
-    const transaction: Transaction = {
-      family: "hedera",
-      amount: new BigNumber(100),
-      recipient: "0.0.456",
-      maxFee: new BigNumber(50),
-    };
-
-    const result = await buildUnsignedTransaction({ account: mockAccount, transaction });
-    expect(result.maxTransactionFee?.toTinybars().toNumber()).toBe(50);
-  });
-});

package/src/api/network.ts

@@ -1,125 +0,0 @@
-import invariant from "invariant";
-import type { Transaction as HederaTransaction, TransactionResponse } from "@hashgraph/sdk";
-import {
-  Client,
-  TransferTransaction,
-  Hbar,
-  AccountId,
-  TransactionId,
-  TokenAssociateTransaction,
-} from "@hashgraph/sdk";
-import type { Account, TokenAccount } from "@ledgerhq/types-live";
-import { findSubAccountById, isTokenAccount } from "@ledgerhq/coin-framework/account/helpers";
-import { Transaction } from "../types";
-import { isTokenAssociateTransaction } from "../logic";
-
-export function broadcastTransaction(transaction: HederaTransaction): Promise<TransactionResponse> {
-  return transaction.execute(getHederaClient());
-}
-
-// https://github.com/LedgerHQ/ledger-live/pull/72/commits/1e942687d4301660e43e0c4b5419fcfa2733b290
-const nodeAccountIds: AccountId[] = [new AccountId(3)];
-
-async function buildUnsignedCoinTransaction({
-  account,
-  transaction,
-}: {
-  account: Account;
-  transaction: Transaction;
-}): Promise<TransferTransaction> {
-  const accountId = account.freshAddress;
-  const hbarAmount = Hbar.fromTinybars(transaction.amount);
-
-  const tx = new TransferTransaction()
-    .setNodeAccountIds(nodeAccountIds)
-    .setTransactionId(TransactionId.generate(accountId))
-    .setTransactionMemo(transaction.memo ?? "")
-    .addHbarTransfer(accountId, hbarAmount.negated())
-    .addHbarTransfer(transaction.recipient, hbarAmount);
-
-  if (transaction.maxFee) {
-    tx.setMaxTransactionFee(Hbar.fromTinybars(transaction.maxFee.toNumber()));
-  }
-
-  return tx.freeze();
-}
-
-async function buildUnsignedTokenTransaction({
-  account,
-  tokenAccount,
-  transaction,
-}: {
-  account: Account;
-  tokenAccount: TokenAccount;
-  transaction: Transaction;
-}): Promise<TransferTransaction> {
-  const accountId = account.freshAddress;
-  const tokenId = tokenAccount.token.contractAddress;
-
-  const tx = new TransferTransaction()
-    .setNodeAccountIds(nodeAccountIds)
-    .setTransactionId(TransactionId.generate(accountId))
-    .setTransactionMemo(transaction.memo ?? "")
-    .addTokenTransfer(tokenId, accountId, transaction.amount.negated().toNumber())
-    .addTokenTransfer(tokenId, transaction.recipient, transaction.amount.toNumber());
-
-  if (transaction.maxFee) {
-    tx.setMaxTransactionFee(Hbar.fromTinybars(transaction.maxFee.toNumber()));
-  }
-
-  return tx.freeze();
-}
-
-async function buildTokenAssociateTransaction({
-  account,
-  transaction,
-}: {
-  account: Account;
-  transaction: Transaction;
-}): Promise<TokenAssociateTransaction> {
-  invariant(isTokenAssociateTransaction(transaction), "invalid transaction properties");
-
-  const accountId = account.freshAddress;
-
-  const tx = new TokenAssociateTransaction()
-    .setNodeAccountIds(nodeAccountIds)
-    .setTransactionId(TransactionId.generate(accountId))
-    .setTransactionMemo(transaction.memo ?? "")
-    .setAccountId(accountId)
-    .setTokenIds([transaction.properties.token.contractAddress]);
-
-  if (transaction.maxFee) {
-    tx.setMaxTransactionFee(Hbar.fromTinybars(transaction.maxFee.toNumber()));
-  }
-
-  return tx.freeze();
-}
-
-export async function buildUnsignedTransaction({
-  account,
-  transaction,
-}: {
-  account: Account;
-  transaction: Transaction;
-}): Promise<TransferTransaction | TokenAssociateTransaction> {
-  const subAccount = findSubAccountById(account, transaction?.subAccountId || "");
-  const isTokenTransaction = isTokenAccount(subAccount);
-
-  if (isTokenAssociateTransaction(transaction)) {
-    return buildTokenAssociateTransaction({ account, transaction });
-  } else if (isTokenTransaction) {
-    return buildUnsignedTokenTransaction({ account, tokenAccount: subAccount, transaction });
-  } else {
-    return buildUnsignedCoinTransaction({ account, transaction });
-  }
-}
-
-let _hederaClient: Client | null = null;
-
-export function getHederaClient(): Client {
-  _hederaClient ??= Client.forMainnet().setMaxNodesPerTransaction(1);
-
-  //_hederaClient.setNetwork({ mainnet: "https://hedera.coin.ledger.com" });
-
-  return _hederaClient;
-}

package/src/api/utils.ts

@@ -1,150 +0,0 @@
-import BigNumber from "bignumber.js";
-import { AccountId } from "@hashgraph/sdk";
-import type { Operation, OperationType } from "@ledgerhq/types-live";
-import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
-import { encodeTokenAccountId } from "@ledgerhq/coin-framework/account";
-import { findTokenByAddressInCurrency } from "@ledgerhq/cryptoassets";
-import type { HederaMirrorTokenTransfer, HederaMirrorCoinTransfer } from "./types";
-import { getAccountTransactions } from "./mirror";
-import { base64ToUrlSafeBase64 } from "../bridge/utils";
-
-function isValidRecipient(accountId: AccountId, recipients: string[]): boolean {
-  if (accountId.shard.eq(0) && accountId.realm.eq(0)) {
-    // account is a node, only add to list if we have none
-    if (accountId.num.lt(100)) {
-      return recipients.length === 0;
-    }
-
-    // account is a system account that is not a node, do NOT add
-    if (accountId.num.lt(1000)) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-export function parseTransfers(
-  mirrorTransfers: (HederaMirrorCoinTransfer | HederaMirrorTokenTransfer)[],
-  address: string,
-): Pick<Operation, "type" | "value" | "senders" | "recipients"> {
-  let value = new BigNumber(0);
-  let type: OperationType = "NONE";
-
-  const senders: string[] = [];
-  const recipients: string[] = [];
-
-  for (const transfer of mirrorTransfers) {
-    const amount = new BigNumber(transfer.amount);
-    const accountId = AccountId.fromString(transfer.account);
-
-    if (transfer.account === address) {
-      value = amount.abs();
-      type = amount.isNegative() ? "OUT" : "IN";
-    }
-
-    if (amount.isNegative()) {
-      senders.push(transfer.account);
-    } else if (isValidRecipient(accountId, recipients)) {
-      recipients.push(transfer.account);
-    }
-  }
-
-  // NOTE: earlier addresses are the "fee" addresses
-  senders.reverse();
-  recipients.reverse();
-
-  return {
-    type,
-    value,
-    senders,
-    recipients,
-  };
-}
-
-export async function getOperationsForAccount(
-  ledgerAccountId: string,
-  address: string,
-  latestOperationTimestamp: string | null,
-): Promise<{
-  coinOperations: Operation[];
-  tokenOperations: Operation[];
-}> {
-  const mirrorTransactions = await getAccountTransactions(address, latestOperationTimestamp);
-  const coinOperations: Operation[] = [];
-  const tokenOperations: Operation[] = [];
-
-  for (const rawTx of mirrorTransactions) {
-    const timestamp = new Date(parseInt(rawTx.consensus_timestamp.split(".")[0], 10) * 1000);
-    const hash = base64ToUrlSafeBase64(rawTx.transaction_hash);
-    const fee = new BigNumber(rawTx.charged_tx_fee);
-    const tokenTransfers = rawTx.token_transfers ?? [];
-    const transfers = rawTx.transfers ?? [];
-    const hasFailed = rawTx.result !== "SUCCESS";
-
-    if (tokenTransfers.length > 0) {
-      const tokenId = rawTx.token_transfers[0].token_id;
-      const token = findTokenByAddressInCurrency(tokenId, "hedera");
-      if (!token) continue;
-
-      const encodedTokenId = encodeTokenAccountId(ledgerAccountId, token);
-      const { type, value, senders, recipients } = parseTransfers(rawTx.token_transfers, address);
-
-      // add main FEES coin operation for send token transfer
-      if (type === "OUT") {
-        coinOperations.push({
-          id: encodeOperationId(ledgerAccountId, hash, "FEES"),
-          accountId: ledgerAccountId,
-          type: "FEES",
-          value: fee,
-          recipients,
-          senders,
-          hash,
-          fee,
-          date: timestamp,
-          blockHeight: 5,
-          blockHash: null,
-          hasFailed,
-          extra: { consensusTimestamp: rawTx.consensus_timestamp },
-        });
-      }
-
-      tokenOperations.push({
-        id: encodeOperationId(encodedTokenId, hash, type),
-        accountId: encodedTokenId,
-        type,
-        value,
-        recipients,
-        senders,
-        hash,
-        fee,
-        date: timestamp,
-        blockHeight: 5,
-        blockHash: null,
-        hasFailed,
-        extra: { consensusTimestamp: rawTx.consensus_timestamp },
-      });
-    } else if (transfers.length > 0) {
-      const { type, value, senders, recipients } = parseTransfers(rawTx.transfers, address);
-      const operationType = rawTx.name === "TOKENASSOCIATE" ? "ASSOCIATE_TOKEN" : type;
-
-      coinOperations.push({
-        id: encodeOperationId(ledgerAccountId, hash, operationType),
-        accountId: ledgerAccountId,
-        type: operationType,
-        value,
-        recipients,
-        senders,
-        hash,
-        fee,
-        date: timestamp,
-        blockHeight: 5,
-        blockHash: null,
-        hasFailed,
-        extra: { consensusTimestamp: rawTx.consensus_timestamp },
-      });
-    }
-  }
-
-  return { coinOperations, tokenOperations };
-}

package/src/logic.test.ts

@@ -1,152 +0,0 @@
-import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
-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);
-    });
-  });
-
-  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,66 +0,0 @@
-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 = 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 hederaAccount?.hederaResources?.isAutoTokenAssociationEnabled ?? false;
-};
-
-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,
-};