@ledgerhq/coin-icon 0.4.1-next.0

package/src/__test__/unit/logic.unit.test.ts

@@ -0,0 +1,145 @@
+import { BigNumber } from "bignumber.js";
+import IconService from "icon-sdk-js";
+import {
+  convertLoopToIcx,
+  convertICXtoLoop,
+  EXISTENTIAL_DEPOSIT,
+  MAX_AMOUNT_INPUT,
+  isValidAddress,
+  isSelfTransaction,
+  getNonce,
+  isTestnet,
+  getNid,
+  calculateAmount,
+  getMinimumBalance,
+} from "../../logic";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
+
+import type { Account } from "@ledgerhq/types-live";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { IconAccount, Transaction } from "../../types";
+import { BERLIN_TESTNET_NID, MAINNET_NID } from "../../constants";
+
+jest.mock("@ledgerhq/cryptoassets", () => ({
+  getCryptoCurrencyById: jest.fn(),
+}));
+
+const { IconAmount } = IconService;
+
+describe("Icon Utils", () => {
+  describe("Conversion functions", () => {
+    it("should convert loop to ICX correctly", () => {
+      const value = "1000000000000000000";
+      const result = convertLoopToIcx(value);
+      expect(
+        result.isEqualTo(new BigNumber(IconAmount.fromLoop(value, IconAmount.Unit.ICX.toString()))),
+      ).toBe(true);
+    });
+
+    it("should convert ICX to loop correctly", () => {
+      const value = "1";
+      const result = convertICXtoLoop(value);
+      expect(
+        result.isEqualTo(new BigNumber(IconAmount.toLoop(value, IconAmount.Unit.ICX.toString()))),
+      ).toBe(true);
+    });
+  });
+
+  describe("Validation functions", () => {
+    it("should validate address correctly", () => {
+      const validAddress = "hx1234567890123456789012345678901234567890";
+      const invalidAddress = "hx12345";
+      expect(isValidAddress(validAddress)).toBe(true);
+      expect(isValidAddress(invalidAddress)).toBe(false);
+    });
+  });
+
+  describe("Transaction-related functions", () => {
+    it("should identify self transaction correctly", () => {
+      const account = { freshAddress: "hx1234567890123456789012345678901234567890" } as Account;
+      const transaction = {
+        recipient: "hx1234567890123456789012345678901234567890",
+      } as Transaction;
+      expect(isSelfTransaction(account, transaction)).toBe(true);
+    });
+
+    it("should get nonce correctly", () => {
+      const account: IconAccount = {
+        iconResources: { nonce: 5 },
+        pendingOperations: [{ transactionSequenceNumber: 4 }],
+      } as IconAccount;
+      expect(getNonce(account)).toBe(5);
+
+      account.pendingOperations = [{ transactionSequenceNumber: 6 }] as any;
+      expect(getNonce(account)).toBe(7);
+    });
+  });
+
+  describe("Network-related functions", () => {
+    it("should identify testnet correctly", () => {
+      (getCryptoCurrencyById as jest.Mock).mockReturnValue({ isTestnetFor: true });
+      const currency = { id: "icon" } as CryptoCurrency;
+      expect(isTestnet(currency)).toBe(true);
+    });
+
+    it("should return correct network ID", () => {
+      (getCryptoCurrencyById as jest.Mock).mockReturnValue({ isTestnetFor: true });
+      const currency = { id: "icon" } as CryptoCurrency;
+      expect(getNid(currency)).toBe(BERLIN_TESTNET_NID);
+
+      (getCryptoCurrencyById as jest.Mock).mockReturnValue({ isTestnetFor: false });
+      expect(getNid(currency)).toBe(MAINNET_NID);
+    });
+  });
+
+  describe("Amount calculation functions", () => {
+    it("should calculate correct amount if useAllAmount is true and mode is send", () => {
+      const account = {
+        spendableBalance: new BigNumber(1000),
+      } as IconAccount;
+      const transaction = {
+        useAllAmount: true,
+        mode: "send",
+        fees: new BigNumber(10),
+      } as Transaction;
+
+      const result = calculateAmount({ account, transaction });
+      expect(result.isEqualTo(new BigNumber(990))).toBe(true);
+    });
+
+    it("should calculate correct amount if useAllAmount is true and mode is not send", () => {
+      const account = {
+        spendableBalance: new BigNumber(1000),
+      } as IconAccount;
+      const transaction = {
+        useAllAmount: true,
+        mode: "other",
+        fees: new BigNumber(10),
+      } as Transaction;
+
+      const result = calculateAmount({ account, transaction });
+      expect(result.isEqualTo(new BigNumber(990))).toBe(true);
+    });
+
+    it("should limit amount to MAX_AMOUNT_INPUT", () => {
+      const account = {} as IconAccount;
+      const transaction = {
+        useAllAmount: false,
+        amount: new BigNumber(10000000000000000000000000000000000),
+      } as Transaction;
+
+      const result = calculateAmount({ account, transaction });
+      expect(result.isEqualTo(new BigNumber(MAX_AMOUNT_INPUT))).toBe(true);
+    });
+
+    it("should calculate minimum balance correctly", () => {
+      const account = {
+        balance: new BigNumber(1000),
+        spendableBalance: new BigNumber(900),
+      } as Account;
+
+      const result = getMinimumBalance(account);
+      expect(result.isEqualTo(EXISTENTIAL_DEPOSIT.minus(new BigNumber(100)))).toBe(true);
+    });
+  });
+});

package/src/__test__/unit/serializations.unit.test.ts

@@ -0,0 +1,92 @@
+import { BigNumber } from "bignumber.js";
+
+import type { Account, AccountRaw } from "@ledgerhq/types-live";
+import { IconAccount, IconAccountRaw, IconResources, IconResourcesRaw } from "../../types";
+import {
+  assignFromAccountRaw,
+  assignToAccountRaw,
+  fromIconResourcesRaw,
+  toIconResourcesRaw,
+} from "../../serialization";
+
+describe("Icon Resources Utilities", () => {
+  describe("toIconResourcesRaw", () => {
+    it("should convert IconResources to IconResourcesRaw", () => {
+      const resources: IconResources = {
+        nonce: 1,
+        votingPower: new BigNumber(1000),
+        totalDelegated: new BigNumber(2000),
+      };
+
+      const expectedRaw: IconResourcesRaw = {
+        nonce: 1,
+        votingPower: "1000",
+        totalDelegated: "2000",
+      };
+
+      expect(toIconResourcesRaw(resources)).toEqual(expectedRaw);
+    });
+  });
+
+  describe("fromIconResourcesRaw", () => {
+    it("should convert IconResourcesRaw to IconResources", () => {
+      const rawResources: IconResourcesRaw = {
+        nonce: 1,
+        votingPower: "1000",
+        totalDelegated: "2000",
+      };
+
+      const expectedResources: IconResources = {
+        nonce: 1,
+        votingPower: new BigNumber(1000),
+        totalDelegated: new BigNumber(2000),
+      };
+
+      expect(fromIconResourcesRaw(rawResources)).toEqual(expectedResources);
+    });
+  });
+
+  describe("assignToAccountRaw", () => {
+    it("should assign IconResources to AccountRaw", () => {
+      const account: IconAccount = {
+        iconResources: {
+          nonce: 1,
+          votingPower: new BigNumber(1000),
+          totalDelegated: new BigNumber(2000),
+        },
+      } as IconAccount;
+
+      const accountRaw: AccountRaw = {} as IconAccountRaw;
+
+      assignToAccountRaw(account as Account, accountRaw);
+
+      expect((accountRaw as IconAccountRaw).iconResources).toEqual({
+        nonce: 1,
+        votingPower: "1000",
+        totalDelegated: "2000",
+      });
+    });
+  });
+
+  describe("assignFromAccountRaw", () => {
+    it("should assign IconResourcesRaw to Account", () => {
+      const accountRaw = {
+        iconResources: {
+          nonce: 1,
+          votingPower: "1000",
+          totalDelegated: "2000",
+        },
+      } as any;
+
+      const account: Account = {} as IconAccount;
+
+      assignFromAccountRaw(accountRaw as AccountRaw, account);
+
+      expect((account as IconAccount).iconResources).toEqual({
+        nonce: 1,
+        votingPower: new BigNumber(1000),
+        totalDelegated: new BigNumber(2000),
+      });
+    });
+  });
+});

package/src/__test__/unit/transaction.unit.test.ts

@@ -0,0 +1,144 @@
+import { BigNumber } from "bignumber.js";
+import type { Account } from "@ledgerhq/types-live";
+import { getAccountCurrency } from "@ledgerhq/coin-framework/account";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies";
+import { formatTransaction, fromTransactionRaw, toTransactionRaw } from "../../transaction";
+
+jest.mock("@ledgerhq/coin-framework/account", () => ({
+  getAccountCurrency: jest.fn(),
+}));
+
+jest.mock("@ledgerhq/coin-framework/currencies", () => ({
+  formatCurrencyUnit: jest.fn(),
+}));
+
+describe("Transaction Utilities", () => {
+  describe("formatTransaction", () => {
+    it("should format a transaction correctly", () => {
+      const transaction = {
+        mode: "send",
+        amount: new BigNumber(1000),
+        recipient: "recipient-address",
+        useAllAmount: false,
+      } as any;
+      const account = {
+        currency: {
+          units: [{ code: "ICX", name: "ICX", magnitude: 18 }],
+        },
+      } as any;
+
+      (getAccountCurrency as jest.Mock).mockReturnValue(account.currency);
+      (formatCurrencyUnit as jest.Mock).mockReturnValue("1 ICX");
+
+      const formatted = formatTransaction(transaction, account);
+      expect(formatted).toBe("\nSEND  1 ICX\nTO recipient-address");
+    });
+
+    it("should handle useAllAmount correctly", () => {
+      const transaction = {
+        mode: "send",
+        amount: new BigNumber(0),
+        recipient: "recipient-address",
+        useAllAmount: true,
+      } as any;
+      const account = {
+        currency: {
+          units: [{ code: "ICX", name: "ICX", magnitude: 8 }],
+        },
+      };
+
+      (getAccountCurrency as jest.Mock).mockReturnValue(account.currency);
+
+      const formatted = formatTransaction(transaction, account as Account);
+      expect(formatted).toBe("\nSEND MAX\nTO recipient-address");
+    });
+  });
+
+  describe("fromTransactionRaw", () => {
+    it("should convert a raw transaction to a transaction", () => {
+      const rawTransaction = {
+        family: "ICX",
+        mode: "send",
+        amount: "1000",
+        recipient: "recipient-address",
+        fees: "10",
+        stepLimit: "1000",
+      } as any;
+
+      const transaction = fromTransactionRaw(rawTransaction);
+      expect(transaction).toEqual({
+        family: "ICX",
+        mode: "send",
+        amount: new BigNumber(1000),
+        recipient: "recipient-address",
+        fees: new BigNumber(10),
+        stepLimit: new BigNumber(1000),
+      });
+    });
+
+    it("should handle null and undefined fields", () => {
+      const rawTransaction = {
+        family: "ICX",
+        mode: "send",
+        amount: "1000",
+        recipient: "recipient-address",
+        fees: null,
+        stepLimit: undefined,
+      } as any;
+
+      const transaction = fromTransactionRaw(rawTransaction);
+      expect(transaction).toEqual({
+        family: "ICX",
+        mode: "send",
+        amount: new BigNumber(1000),
+        recipient: "recipient-address",
+        fees: null,
+        stepLimit: undefined,
+      });
+    });
+  });
+
+  describe("toTransactionRaw", () => {
+    it("should convert a transaction to a raw transaction", () => {
+      const transaction = {
+        family: "ICX",
+        mode: "send",
+        amount: new BigNumber(1000),
+        recipient: "recipient-address",
+        fees: new BigNumber(10),
+        stepLimit: new BigNumber(1000),
+      } as any;
+
+      const rawTransaction = toTransactionRaw(transaction);
+      expect(rawTransaction).toEqual({
+        family: "ICX",
+        mode: "send",
+        amount: "1000",
+        recipient: "recipient-address",
+        fees: "10",
+        stepLimit: "1000",
+      });
+    });
+
+    it("should handle null and undefined fields", () => {
+      const transaction = {
+        family: "ICX",
+        mode: "send",
+        amount: new BigNumber(1000),
+        recipient: "recipient-address",
+        fees: null,
+        stepLimit: undefined,
+      } as any;
+
+      const rawTransaction = toTransactionRaw(transaction);
+      expect(rawTransaction).toEqual({
+        family: "ICX",
+        mode: "send",
+        amount: "1000",
+        recipient: "recipient-address",
+        fees: null,
+        stepLimit: undefined,
+      });
+    });
+  });
+});

package/src/account.ts

@@ -0,0 +1,30 @@
+import { getAccountCurrency } from "@ledgerhq/coin-framework/account/index";
+import { IconAccount } from "./types";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+
+function formatAccountSpecifics(account: IconAccount): string {
+  const { iconResources } = account;
+  if (!iconResources) {
+    throw new Error("icon account expected");
+  }
+
+  const unit = getAccountCurrency(account).units[0];
+  const formatConfig = {
+    disableRounding: true,
+    alwaysShowSign: false,
+    showCode: true,
+  };
+
+  let str = " ";
+
+  str += formatCurrencyUnit(unit, account.spendableBalance, formatConfig) + " spendable. ";
+
+  if (iconResources.nonce) {
+    str += "\nonce : " + iconResources.nonce;
+  }
+
+  return str;
+}
+export default {
+  formatAccountSpecifics,
+};

package/src/api/api-type.ts

@@ -0,0 +1,65 @@
+import BigNumber from "bignumber.js";
+
+/**
+ * Icon Account
+ */
+export type AccountType = {
+  address: string;
+  audit_tx_hash: string;
+  balance: number; //9.998855272082496
+  code_hash: string;
+  contract_type: string;
+  contract_updated_block: number; // 0
+  created_timestamp: number; // 0
+  deploy_tx_hash: string;
+  is_contract: boolean;
+  is_nft: boolean;
+  is_prep: boolean;
+  is_token: boolean;
+  log_count: number;
+  name: string;
+  owner: string;
+  status: string;
+  symbol: string;
+  token_standard: string;
+  token_transfer_count: number;
+  transaction_count: number;
+  transaction_internal_count: number;
+  type: string;
+};
+
+/**
+ * Icon TransactionType
+ */
+export type IconTransactionType = {
+  block_number: number;
+  block_timestamp: number;
+  data: string;
+  from_address: string;
+  hash: string;
+  method: string;
+  status: string; // 010
+  to_address: string;
+  transaction_fee: string; // 0x470de4df82000"
+  transaction_type: number;
+  type: number;
+  value: string; //0x470de4df82000
+  value_decimal: number; // 4
+};
+
+/**
+ *   Icon Delegation item Type
+ */
+export type IconDelegationItemType = {
+  address: string;
+  value: string;
+};
+
+/**
+ *   Icon DelegationType
+ */
+export type IconDelegationType = {
+  delegations: IconDelegationItemType[];
+  totalDelegated: BigNumber;
+  votingPower: BigNumber;
+};

package/src/api/index.ts

@@ -0,0 +1,156 @@
+import network from "@ledgerhq/live-network/network";
+import { BigNumber } from "bignumber.js";
+import type { Operation, OperationType } from "@ledgerhq/types-live";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { LIMIT } from "../constants";
+import { isTestnet } from "../logic";
+import { AccountType, IconTransactionType } from "./api-type";
+import { log } from "@ledgerhq/logs";
+import { IconOperation } from "../types/index";
+import querystring from "querystring";
+import { getCoinConfig } from "../config";
+
+/**
+ * Returns Testnet API URL if the current network is testnet
+ *
+ * @param {network} network
+ */
+function getApiUrl(network: CryptoCurrency): string {
+  const currencyConfig = getCoinConfig();
+  let apiUrl = currencyConfig.infra.indexer;
+  if (isTestnet(network)) {
+    apiUrl = currencyConfig.infra.indexer_testnet;
+  }
+  return apiUrl;
+}
+
+async function fetch(url: string) {
+  const { data } = await network({
+    method: "GET",
+    url,
+  });
+
+  if (data.Error) {
+    log("icon-error", data.Error, {
+      url,
+    });
+    throw new Error(data.Error);
+  }
+
+  return data;
+}
+
+export const getAccount = async (addr: string, network: CryptoCurrency): Promise<AccountType> => {
+  const data = await fetch(`${getApiUrl(network)}/addresses/details/${addr}`);
+  return data;
+};
+
+export const getCurrentBlockHeight = async (
+  network: CryptoCurrency,
+): Promise<number | undefined> => {
+  const data = await fetch(`${getApiUrl(network)}/blocks`);
+  return data?.[0].number;
+};
+
+/**
+ * Returns true if account is the signer
+ */
+function isSender(transaction: IconTransactionType, addr: string): boolean {
+  return transaction.from_address === addr;
+}
+
+/**
+ * Map transaction to an Operation Type
+ */
+function getOperationType(transaction: IconTransactionType, addr: string): OperationType {
+  return isSender(transaction, addr) ? "OUT" : "IN";
+}
+
+/**
+ * Map transaction to a correct Operation Value (affecting account balance)
+ */
+function getOperationValue(transaction: IconTransactionType, addr: string): BigNumber {
+  if (isSender(transaction, addr)) {
+    return transaction.value
+      ? new BigNumber(transaction.value).plus(transaction.transaction_fee)
+      : new BigNumber(0);
+  } else {
+    return transaction.value ? new BigNumber(transaction.value) : new BigNumber(0);
+  }
+}
+
+/**
+ * Map the ICON history transaction to a Ledger Live Operation
+ */
+function txToOperation(
+  accountId: string,
+  addr: string,
+  transaction: IconTransactionType,
+): IconOperation {
+  const type = getOperationType(transaction, addr);
+
+  return {
+    id: encodeOperationId(accountId, transaction.hash, type),
+    accountId,
+    fee: new BigNumber(transaction.transaction_fee),
+    value: getOperationValue(transaction, addr),
+    type,
+    hash: transaction.hash,
+    blockHash: null,
+    blockHeight: transaction.block_number,
+    date: new Date(transaction.block_timestamp / 1000),
+    senders: [transaction.from_address],
+    recipients: [transaction.to_address],
+    extra: {},
+    hasFailed: transaction.status !== "0x1",
+  };
+}
+
+/**
+ * Fetch operation list
+ */
+export const getOperations = async (
+  accountId: string,
+  addr: string,
+  skip: number,
+  network: CryptoCurrency,
+  maxLength: number,
+): Promise<Operation[]> => {
+  return await fetchOperationList(accountId, addr, skip, network, maxLength);
+};
+
+export const fetchOperationList = async (
+  accountId: string,
+  addr: string,
+  skip: number,
+  network: CryptoCurrency,
+  maxLength: number,
+  prevOperations: IconOperation[] = [],
+): Promise<IconOperation[]> => {
+  const data = await getTxHistory(addr, skip, network);
+  const operations = data.map((transaction: IconTransactionType) =>
+    txToOperation(accountId, addr, transaction),
+  );
+
+  const mergedOp = [...prevOperations, ...operations];
+  if (operations.length < LIMIT || operations.length >= maxLength) {
+    return mergedOp;
+  }
+  return await fetchOperationList(accountId, addr, skip + LIMIT, network, maxLength, mergedOp);
+};
+
+export const getTxHistory = async (
+  addr: string,
+  skip: number,
+  network: CryptoCurrency,
+  limit: number = LIMIT,
+): Promise<IconTransactionType[]> => {
+  const query = querystring.stringify({
+    skip: skip,
+    limit: limit,
+  });
+
+  const data = await fetch(`${getApiUrl(network)}/transactions/address/${addr}?${query}`);
+  return data;
+};