@ledgerhq/coin-icon 0.4.1-next.0

package/lib-es/types/index.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.js.map

package/lib-es/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@ledgerhq/coin-icon",
+  "version": "0.4.1-next.0",
+  "description": "Ledger Icon Coin integration",
+  "keywords": [
+    "Ledger",
+    "LedgerWallet",
+    "icx",
+    "Icon",
+    "Hardware Wallet"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/LedgerHQ/ledger-live.git"
+  },
+  "bugs": {
+    "url": "https://github.com/LedgerHQ/ledger-live/issues"
+  },
+  "homepage": "https://github.com/LedgerHQ/ledger-live/tree/develop/libs/coin-modules/coin-icon",
+  "publishConfig": {
+    "access": "public"
+  },
+  "typesVersions": {
+    "*": {
+      "lib/*": [
+        "lib/*"
+      ],
+      "lib-es/*": [
+        "lib-es/*"
+      ],
+      "*": [
+        "lib/*"
+      ]
+    }
+  },
+  "exports": {
+    "./lib/*": "./lib/*.js",
+    "./lib-es/*": "./lib-es/*.js",
+    "./*": {
+      "require": "./lib/*.js",
+      "default": "./lib-es/*.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "license": "Apache-2.0",
+  "dependencies": {
+    "@faker-js/faker": "^8.4.1",
+    "bignumber.js": "^9.1.2",
+    "expect": "^27.4.6",
+    "icon-sdk-js": "1.5.2",
+    "invariant": "^2.2.2",
+    "lodash": "^4.17.21",
+    "prando": "^6.0.1",
+    "rxjs": "^7.8.1",
+    "@ledgerhq/coin-framework": "^0.17.0-next.0",
+    "@ledgerhq/cryptoassets": "^13.3.0-next.0",
+    "@ledgerhq/devices": "^8.4.2",
+    "@ledgerhq/errors": "^6.18.0",
+    "@ledgerhq/live-env": "^2.2.0-next.0",
+    "@ledgerhq/live-network": "^1.4.0-next.0",
+    "@ledgerhq/live-promise": "^0.1.0",
+    "@ledgerhq/logs": "^6.12.0",
+    "@ledgerhq/types-cryptoassets": "^7.15.0-next.0",
+    "@ledgerhq/types-live": "^6.50.0-next.0"
+  },
+  "devDependencies": {
+    "@types/invariant": "^2.2.2",
+    "@types/jest": "^29.5.10",
+    "@types/lodash": "^4.14.191",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.1"
+  },
+  "scripts": {
+    "coverage": "jest --coverage --testPathIgnorePatterns='/bridge.integration.test.ts|node_modules|lib-es|lib/' --passWithNoTests && mv coverage/coverage-final.json coverage/coverage-icon.json",
+    "clean": "rimraf lib lib-es",
+    "build": "tsc && tsc -m ES6 --outDir lib-es",
+    "prewatch": "pnpm build",
+    "watch": "tsc --watch",
+    "doc": "documentation readme src/** --section=API --pe ts --re ts --re d.ts",
+    "lint": "eslint ./src --no-error-on-unmatched-pattern --ext .ts,.tsx --cache",
+    "lint:fix": "pnpm lint --fix",
+    "test": "jest",
+    "unimported": "unimported"
+  }
+}

package/src/__test__/api/index.unit.test.ts

@@ -0,0 +1,151 @@
+import network from "@ledgerhq/live-network/network";
+import type { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+
+import { fetchOperationList } from "../../api";
+import { IconTransactionType } from "../../api/api-type";
+import { isTestnet } from "../../logic";
+import { getCoinConfig } from "../../config";
+import querystring from "querystring";
+import * as contants from "../../constants";
+
+// Mock the necessary modules and functions
+jest.mock("@ledgerhq/live-network/network");
+jest.mock("@ledgerhq/coin-framework/operation");
+jest.mock("@ledgerhq/cryptoassets");
+jest.mock("../../logic");
+jest.mock("../../config");
+jest.mock("querystring");
+jest.mock("@ledgerhq/logs");
+
+describe("ICON API", () => {
+  const networkMock = network as jest.Mock;
+  const isTestnetMock = isTestnet as jest.Mock;
+  const getCoinConfigMock = getCoinConfig as jest.Mock;
+  const querystringMock = querystring.stringify as jest.Mock;
+  const mockedLogic = jest.mocked(contants);
+
+  isTestnetMock.mockReturnValue(true);
+  getCoinConfigMock.mockReturnValue({
+    infra: {
+      indexer: "mainnet-url",
+      indexer_testnet: "testnet-url",
+    },
+  });
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("fetchOperationList", () => {
+    it("should recursively fetch operation list correctly", async () => {
+      const accountId = "accountId";
+      const addr = "hx123";
+      const skip = 0;
+      const network = { id: "icon" } as CryptoCurrency;
+      const maxLength = 10;
+      // @ts-expect-error type
+      mockedLogic.LIMIT = 10;
+
+      const tx1 = {
+        hash: "tx1",
+        from_address: addr,
+        to_address: "hx456",
+        transaction_fee: "10",
+        block_number: 12345,
+        block_timestamp: 1609459200000,
+        status: "0x1",
+        value: "1000",
+      } as IconTransactionType;
+      const tx2 = {
+        hash: "tx2",
+        from_address: "hx456",
+        to_address: addr,
+        transaction_fee: "5",
+        block_number: 12346,
+        block_timestamp: 1609459201000,
+        status: "0x1",
+        value: "2000",
+      } as IconTransactionType;
+      const txHistory = [tx1, tx2];
+      querystringMock.mockReturnValue("address=hx123&skip=0&limit=10");
+      networkMock.mockResolvedValue({ data: txHistory });
+
+      const result = await fetchOperationList(accountId, addr, skip, network, maxLength);
+      expect(result.length).toBe(2);
+      expect(networkMock).toHaveBeenCalledWith({
+        method: "GET",
+        url: `testnet-url/transactions/address/${addr}?address=${addr}&skip=${skip}&limit=${10}`,
+      });
+    });
+    it("should recursively fetch operation list correctly", async () => {
+      const accountId = "accountId";
+      const addr = "hx123";
+      const skip = 0;
+      const network = { id: "icon" } as CryptoCurrency;
+      const maxLength = 10;
+      // @ts-expect-error type
+      mockedLogic.LIMIT = 2; // set a small limit for easier testing
+
+      const tx1 = {
+        hash: "tx1",
+        from_address: addr,
+        to_address: "hx456",
+        transaction_fee: "10",
+        block_number: 12345,
+        block_timestamp: 1609459200000,
+        status: "0x1",
+        value: "1000",
+      } as IconTransactionType;
+      const tx2 = {
+        hash: "tx2",
+        from_address: "hx456",
+        to_address: addr,
+        transaction_fee: "5",
+        block_number: 12346,
+        block_timestamp: 1609459201000,
+        status: "0x1",
+        value: "2000",
+      } as IconTransactionType;
+      const tx3 = {
+        hash: "tx3",
+        from_address: addr,
+        to_address: "hx456",
+        transaction_fee: "15",
+        block_number: 12347,
+        block_timestamp: 1609459202000,
+        status: "0x1",
+        value: "1500",
+      } as IconTransactionType;
+
+      networkMock
+        .mockResolvedValueOnce({ data: [tx1, tx2] }) // First fetch returns two transactions
+        .mockResolvedValueOnce({ data: [tx3] }); // Second fetch returns one transaction
+
+      querystringMock
+        .mockReturnValueOnce("address=hx123&skip=0&limit=2")
+        .mockReturnValueOnce("address=hx123&skip=2&limit=2");
+
+      const result = await fetchOperationList(accountId, addr, skip, network, maxLength);
+
+      // Verify that the function was called recursively
+      expect(networkMock).toHaveBeenCalledTimes(2);
+
+      // Verify that the result includes all transactions fetched
+      expect(result.length).toBe(3);
+      expect(result).toEqual([
+        expect.objectContaining({ hash: "tx1" }),
+        expect.objectContaining({ hash: "tx2" }),
+        expect.objectContaining({ hash: "tx3" }),
+      ]);
+
+      // Verify the URLs used in the network calls
+      expect(networkMock).toHaveBeenCalledWith({
+        method: "GET",
+        url: `testnet-url/transactions/address/${addr}?address=${addr}&skip=${skip}&limit=${2}`,
+      });
+      expect(networkMock).toHaveBeenCalledWith({
+        method: "GET",
+        url: `testnet-url/transactions/address/${addr}?address=${addr}&skip=${skip + 2}&limit=${2}`,
+      });
+    });
+  });
+});

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

@@ -0,0 +1,76 @@
+import BigNumber from "bignumber.js";
+import { Transaction, IconAccount } from "../../types";
+import { createFixtureAccount, createFixtureTransaction } from "../../types/bridge.fixture";
+import { buildTransaction } from "../../buildTransaction";
+
+const mockFrom = jest.fn().mockReturnThis();
+const mockTo = jest.fn().mockReturnThis();
+const mockValue = jest.fn().mockReturnThis();
+const mockNid = jest.fn().mockReturnThis();
+const mockNonce = jest.fn().mockReturnThis();
+const mockTimestamp = jest.fn().mockReturnThis();
+const mockVersion = jest.fn().mockReturnThis();
+const mockStepLimit = jest.fn().mockReturnThis();
+const mockBuild = jest.fn().mockReturnValue("mocked-transaction");
+
+jest.mock("icon-sdk-js", () => ({
+  IconBuilder: {
+    IcxTransactionBuilder: jest.fn().mockImplementation(() => ({
+      from: mockFrom,
+      to: mockTo,
+      value: mockValue,
+      nid: mockNid,
+      nonce: mockNonce,
+      timestamp: mockTimestamp,
+      version: mockVersion,
+      stepLimit: mockStepLimit,
+      build: mockBuild,
+    })),
+  },
+  IconConverter: {
+    toHexNumber: jest.fn(value => `0x${value}`),
+  },
+}));
+
+jest.mock("../../logic", () => ({
+  getNid: jest.fn().mockReturnValue(1),
+  getNonce: jest.fn().mockReturnValue(1),
+}));
+
+describe("buildTransaction", () => {
+  const account = createFixtureAccount() as IconAccount;
+  const transaction = createFixtureTransaction({
+    mode: "send",
+    recipient: "WHATEVER",
+  }) as Transaction;
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should build a transfer transaction", async () => {
+    const stepLimit = new BigNumber(100000);
+    const result = await buildTransaction(account, transaction, stepLimit);
+
+    expect(mockFrom).toHaveBeenCalledWith(account.freshAddress);
+    expect(mockTo).toHaveBeenCalledWith(transaction.recipient);
+    expect(mockValue).toHaveBeenCalledWith(expect.any(String));
+    expect(mockNid).toHaveBeenCalledWith(expect.any(String));
+    expect(mockNonce).toHaveBeenCalledWith(expect.any(String));
+    expect(mockTimestamp).toHaveBeenCalledWith(expect.any(String));
+    expect(mockVersion).toHaveBeenCalledWith(expect.any(String));
+    expect(mockStepLimit).toHaveBeenCalledWith(expect.any(String));
+    expect(result.unsigned).toBe("mocked-transaction");
+  });
+
+  it("should throw an error for unsupported transaction mode", async () => {
+    const invalidTransaction: Transaction = {
+      ...transaction,
+      mode: "invalid-mode",
+    };
+
+    await expect(buildTransaction(account, invalidTransaction)).rejects.toThrow(
+      "Unsupported transaction mode: invalid-mode",
+    );
+  });
+});

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

@@ -0,0 +1,76 @@
+import { BigNumber } from "bignumber.js";
+
+import { getAbandonSeedAddress } from "@ledgerhq/cryptoassets";
+import { IconAccount } from "../../types";
+import { buildTransaction } from "../../buildTransaction";
+import { getFees, getStepPrice } from "../../api/node";
+import getEstimatedFees from "../../getFeesForTransaction";
+import * as logic from "../../logic";
+
+jest.mock("../../buildTransaction");
+jest.mock("../../api/node");
+jest.mock("@ledgerhq/cryptoassets");
+jest.mock("../../logic");
+
+const mockedLogic = jest.mocked(logic);
+
+describe("getEstimatedFees", () => {
+  beforeAll(() => {
+    (global as any).FEES_SAFETY_BUFFER = new BigNumber(100);
+  });
+  it("should fetch the estimated fees correctly", async () => {
+    const account: IconAccount = {
+      currency: { id: "icon" },
+      spendableBalance: new BigNumber(1000),
+      pendingOperations: [],
+      iconResources: { nonce: 1 },
+    } as any;
+
+    const transaction = {
+      amount: new BigNumber(100),
+      recipient: "recipient-address",
+      fees: new BigNumber(10),
+    } as any;
+
+    const unsignedTx = {
+      /* mock unsigned transaction */
+    };
+    const stepLimit = new BigNumber(100000);
+    const stepPrice = new BigNumber(10);
+
+    (getAbandonSeedAddress as jest.Mock).mockReturnValue("fake-recipient-address");
+    mockedLogic.calculateAmount.mockReturnValue(new BigNumber(100));
+    (buildTransaction as jest.Mock).mockResolvedValue({ unsigned: unsignedTx });
+    (getFees as jest.Mock).mockResolvedValue(stepLimit);
+    (getStepPrice as jest.Mock).mockResolvedValue(stepPrice);
+
+    const estimatedFees = await getEstimatedFees({ account, transaction });
+    expect(estimatedFees.isEqualTo(stepLimit.multipliedBy(stepPrice))).toBe(true);
+    expect(transaction.stepLimit).toEqual(stepLimit);
+  });
+
+  it("should return FEES_SAFETY_BUFFER if an error occurs", async () => {
+    const account = {
+      currency: { id: "icon" },
+      spendableBalance: new BigNumber(1000),
+      pendingOperations: [],
+      iconResources: { nonce: 1 },
+    } as any;
+
+    const transaction = {
+      amount: new BigNumber(100),
+      recipient: "recipient-address",
+      fees: new BigNumber(10),
+    } as any;
+
+    (getAbandonSeedAddress as jest.Mock).mockReturnValue("fake-recipient-address");
+    mockedLogic.calculateAmount.mockReturnValue(new BigNumber(100));
+    // @ts-expect-error type
+    mockedLogic.FEES_SAFETY_BUFFER = new BigNumber(100);
+    (buildTransaction as jest.Mock).mockRejectedValue(new Error("Error"));
+    // Mock getFees and getStepPrice if necessary, but they won't be called in this test case
+
+    const estimatedFees = await getEstimatedFees({ account, transaction });
+    expect(estimatedFees.isEqualTo(new BigNumber(100))).toBe(true);
+  });
+});

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

@@ -0,0 +1,172 @@
+import { BigNumber } from "bignumber.js";
+import {
+  NotEnoughBalance,
+  RecipientRequired,
+  InvalidAddress,
+  FeeNotLoaded,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  AmountRequired,
+} from "@ledgerhq/errors";
+import * as logic from "../../logic";
+import { IconAccount, Transaction } from "../../types";
+import { getSendTransactionStatus, getTransactionStatus } from "../../getTransactionStatus";
+import * as TransactionStatus from "../../getTransactionStatus";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+import { CryptoCurrency } from "@ledgerhq/types-cryptoassets";
+import { IconDoMaxSendInstead } from "../../errors";
+
+jest.mock("../../logic");
+jest.mock("../../api");
+jest.mock("@ledgerhq/coin-framework/currencies/index");
+
+const mockedLogic = jest.mocked(logic);
+const mockedFormatCurrencyUnit = jest.mocked(formatCurrencyUnit);
+
+describe("getSendTransactionStatus", () => {
+  let account: IconAccount;
+  let transaction: Transaction;
+
+  beforeEach(() => {
+    account = {
+      spendableBalance: new BigNumber(1000),
+      currency: {
+        name: "Icon",
+        units: [
+          {
+            code: "ICX",
+            name: "",
+            magnitude: 0,
+          },
+        ],
+      } as CryptoCurrency,
+      iconResources: {
+        totalDelegated: new BigNumber(0),
+        votingPower: new BigNumber(0),
+        nonce: 0,
+      },
+    } as IconAccount;
+    transaction = {
+      fees: new BigNumber(10),
+      recipient: "test-recipient",
+      useAllAmount: false,
+    } as Transaction;
+    mockedLogic.calculateAmount.mockReturnValue(new BigNumber(100));
+    mockedLogic.getMinimumBalance.mockReturnValue(new BigNumber(50));
+    mockedLogic.isSelfTransaction.mockReturnValue(false);
+    mockedLogic.isValidAddress.mockReturnValue(true);
+    mockedFormatCurrencyUnit.mockReturnValue("1 ICX");
+  });
+
+  it("should return FeeNotLoaded error if fees are not loaded", async () => {
+    transaction.fees = null;
+    const result = await getSendTransactionStatus(account, transaction);
+    expect(result.errors.fees).toBeInstanceOf(FeeNotLoaded);
+  });
+
+  it("should return RecipientRequired error if recipient is missing", async () => {
+    transaction.recipient = "";
+    const result = await getSendTransactionStatus(account, transaction);
+    expect(result.errors.recipient).toBeInstanceOf(RecipientRequired);
+  });
+
+  it("should return InvalidAddressBecauseDestinationIsAlsoSource error if recipient is the same as source", async () => {
+    mockedLogic.isSelfTransaction.mockReturnValue(true);
+    const result = await getSendTransactionStatus(account, transaction);
+    expect(result.errors.recipient).toBeInstanceOf(InvalidAddressBecauseDestinationIsAlsoSource);
+  });
+
+  it("should return InvalidAddress error if recipient is invalid", async () => {
+    mockedLogic.isValidAddress.mockReturnValue(false);
+    const result = await getSendTransactionStatus(account, transaction);
+    expect(result.errors.recipient).toBeInstanceOf(InvalidAddress);
+  });
+
+  it("should return AmountRequired error if amount is less than or equal to zero", async () => {
+    mockedLogic.calculateAmount.mockReturnValue(new BigNumber(0));
+    const result = await getSendTransactionStatus(account, transaction);
+    expect(result.errors.amount).toBeInstanceOf(AmountRequired);
+  });
+
+  it("should return NotEnoughBalance error if total spent exceeds spendable balance", async () => {
+    account.spendableBalance = new BigNumber(50);
+    const result = await getSendTransactionStatus(account, transaction);
+    expect(result.errors.amount).toBeInstanceOf(NotEnoughBalance);
+  });
+
+  it("should return proper TransactionStatus when everything is valid", async () => {
+    const result = await getSendTransactionStatus(account, transaction);
+    expect(result.errors).toEqual({});
+    expect(result.warnings).toEqual({});
+    expect(result.estimatedFees).toEqual(transaction.fees);
+    expect(result.amount).toEqual(new BigNumber(100));
+    expect(result.totalSpent).toEqual(new BigNumber(110));
+  });
+
+  it("should return IconDoMaxSendInstead error if leftover balance is less than minimumBalanceExistential but greater than zero", async () => {
+    account.spendableBalance = new BigNumber(120);
+    const result = await getSendTransactionStatus(account, transaction);
+    expect(result.errors.amount).toBeInstanceOf(IconDoMaxSendInstead);
+    expect(result.errors.amount.message).toBe(
+      "Balance cannot be below {{minimumBalance}}. Send max to empty account.",
+    );
+  });
+});
+
+describe("getTransactionStatus", () => {
+  let account: IconAccount;
+  let transaction: Transaction;
+
+  beforeEach(() => {
+    account = {
+      spendableBalance: new BigNumber(1000),
+      currency: { name: "ICON", units: [{ code: "ICX" }] },
+    } as IconAccount;
+    transaction = {
+      fees: new BigNumber(10),
+      mode: "send",
+      useAllAmount: false,
+    } as Transaction;
+    mockedLogic.calculateAmount.mockReturnValue(new BigNumber(100));
+  });
+
+  it("should delegate to getSendTransactionStatus for send mode", async () => {
+    const sendTransactionStatus = {
+      errors: {},
+      warnings: {},
+      estimatedFees: new BigNumber(10),
+      amount: new BigNumber(100),
+      totalSpent: new BigNumber(110),
+    } as any;
+    jest
+      .spyOn(TransactionStatus, "getSendTransactionStatus")
+      .mockResolvedValue(sendTransactionStatus);
+    const result = await getTransactionStatus(account, transaction);
+    expect(result).toEqual(sendTransactionStatus);
+  });
+
+  it("should handle default case correctly", async () => {
+    transaction.mode = "other";
+    const result = await getTransactionStatus(account, transaction);
+    expect(result.errors).toEqual({});
+    expect(result.warnings).toEqual({});
+    expect(result.estimatedFees).toEqual(transaction.fees);
+    expect(result.amount).toEqual(new BigNumber(100));
+    expect(result.totalSpent).toEqual(new BigNumber(110));
+  });
+
+  it("should return NotEnoughBalance error if totalSpent is greater than spendableBalance", async () => {
+    transaction.mode = "";
+    mockedLogic.calculateAmount.mockReturnValue(new BigNumber(1000));
+    transaction.fees = new BigNumber(100);
+    const result = await getTransactionStatus(account, transaction);
+    expect(result.errors.amount).toBeInstanceOf(NotEnoughBalance);
+  });
+
+  it("should return AmountRequired error if amount is less than or equal to zero and useAllAmount is false", async () => {
+    transaction.mode = "";
+    mockedLogic.calculateAmount.mockReturnValue(new BigNumber(0));
+    transaction.useAllAmount = false;
+    const result = await getTransactionStatus(account, transaction);
+    expect(result.errors.amount).toBeInstanceOf(AmountRequired);
+  });
+});