@ledgerhq/coin-ton 0.3.12-next.0

package/src/__tests__/fixtures/common.fixtures.ts

@@ -0,0 +1,139 @@
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+import { Account } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import {
+  TonAccountInfo,
+  TonResponseEstimateFee,
+  TonResponseWalletInfo,
+  TonTransactionsList,
+} from "../../bridge/bridgeHelpers/api.types";
+import type { Transaction } from "../../types";
+
+export const mockAddress = "UQDzd8aeBOU-jqYw_ZSuZjceI5p-F4b7HMprAsUJAtRPbMol";
+export const mockAccountId =
+  "js:2:ton:b19891a06654f21c64147550b3321bef63acd25b5dd61b688b022c42fac4831d:ton";
+
+export const account = {
+  id: mockAccountId,
+  freshAddress: mockAddress,
+  freshAddressPath: "44'/607'/0'/0'/0'/0'",
+  xpub: "",
+  type: "Account",
+  currency: getCryptoCurrencyById("ton"),
+  spendableBalance: new BigNumber("1000000000"),
+  balance: new BigNumber("1000000000"),
+  seedIdentifier: "seedIdentifier",
+} as Account;
+
+export const transaction = {
+  mode: "send",
+  recipient: "UQCOvQLYvTcbi5tL9MaDNzuVl3-J3vATimNm9yO5XPafLfV4",
+  amount: new BigNumber("1000000"),
+  useAllAmount: false,
+  comment: { isEncrypted: false, text: "" },
+  payload: "",
+  family: "ton",
+} as unknown as Transaction;
+
+export const fees = {
+  in_fwd_fee: 10000,
+  storage_fee: 10000,
+  gas_fee: 10000,
+  fwd_fee: 10000,
+};
+
+export const totalFees = BigNumber(
+  fees.fwd_fee + fees.gas_fee + fees.in_fwd_fee + fees.storage_fee,
+);
+
+export const lastBlockNumber = {
+  last: {
+    seqno: 38574413,
+  },
+  first: {
+    seqno: 3,
+  },
+};
+
+export const tonAccount: TonAccountInfo = {
+  balance: "1000000000",
+  last_transaction_lt: "47055058000008",
+  last_transaction_hash: "psVQqt6rf/Lo6xyLzxx0to0jUIx8I2/4znOVf2KhAI0=",
+  status: "active",
+  seqno: 3,
+};
+
+export const tonWallet: TonResponseWalletInfo = {
+  balance: "7726736262",
+  wallet_type: "wallet v4 r2",
+  seqno: 22,
+  wallet_id: 698983191,
+  last_transaction_lt: "47055058000008",
+  last_transaction_hash: "psVQqt6rf/Lo6xyLzxx0to0jUIx8I2/4znOVf2KhAI0=",
+  status: "active",
+};
+
+export const tonEstimateFee: TonResponseEstimateFee = {
+  source_fees: fees,
+  destination_fees: [],
+};
+
+export const tonTransactionResponse: TonTransactionsList = {
+  transactions: [
+    {
+      account: mockAddress,
+      hash: "hash",
+      lt: "lt",
+      now: 1718241443,
+      orig_status: "active",
+      end_status: "active",
+      total_fees: "0",
+      prev_trans_hash: "",
+      prev_trans_lt: "",
+      description: {
+        aborted: true,
+        destroyed: false,
+        compute_ph: {
+          success: false,
+          exit_code: -14,
+        },
+        credit_first: true,
+      },
+      block_ref: null,
+      in_msg: {
+        source: "0:959EAA8BD0E3A2662D814278D51A6F997946207D48478008BEBE7F45F3EF781F",
+        destination: mockAddress,
+        value: "13509565",
+        hash: "inMsgHash",
+        fwd_fee: "266669",
+        ihr_fee: "0",
+        created_lt: "47055058000007",
+        created_at: "1718241443",
+        opcode: "0xd53276db",
+        ihr_disabled: true,
+        bounce: false,
+        bounced: false,
+        import_fee: null,
+        message_content: {
+          hash: "Qa0w2xg42wA9taurO/aCVOqGTzjOeP3EpzD2Sl7tTss=",
+          body: "te6cckEBAQEADgAAGNUydtsAAAAAAAAAAfRC8y4=",
+          decoded: null,
+        },
+        init_state: null,
+      },
+      out_msgs: [],
+      account_state_before: null,
+      account_state_after: null,
+      mc_block_seqno: 3,
+    },
+  ],
+  address_book: {},
+};
+
+export const accountInfo: TonAccountInfo = {
+  balance: "7726736262",
+  last_transaction_lt: "47055058000008",
+  last_transaction_hash: "lastTransactionHash",
+  status: "active",
+  seqno: 22,
+};

package/src/__tests__/integration/bridge.integration.test.ts

@@ -0,0 +1,135 @@
+import { InvalidAddress, NotEnoughBalance } from "@ledgerhq/errors";
+import { CurrenciesData, DatasetTest } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import { TonCommentInvalid } from "../../errors";
+import { fromTransactionRaw } from "../../transaction";
+import { Transaction } from "../../types";
+
+const PUBKEY = "86196cb40cd25e9e696bc808e3f2c074ce0b39f2a2a9d482a68eafef86e4a060";
+const ADDRESS = "UQCOvQLYvTcbi5tL9MaDNzuVl3-J3vATimNm9yO5XPafLfV4";
+const ADDRESS_2 = "UQAui6M4jOYOezUGfmeONA22Ars9yjd34YIGdAR1Pcpp4sgR";
+const PATH = "44'/607'/0'/0'/0'/0'";
+
+const ton: CurrenciesData<Transaction> = {
+  scanAccounts: [
+    {
+      name: "ton seed 1",
+      apdus: `
+      => e005000019068000002c8000025f80000000800000008000000080000000
+      <= 86196cb40cd25e9e696bc808e3f2c074ce0b39f2a2a9d482a68eafef86e4a0609000
+      => e005000019068000002c8000025f80000000800000008000000180000000
+      <= b5177c2b32f9d72fa8c673cc3d61acec6a9f68eb5e4945445fdbb48a45eb48879000
+      `,
+      test: (expect, accounts) => {
+        for (const account of accounts) {
+          expect(account.derivationMode).toEqual("ton");
+        }
+      },
+    },
+  ],
+  accounts: [
+    {
+      FIXME_tests: ["balance is sum of ops"],
+      raw: {
+        id: `js:2:ton:${PUBKEY}:ton`,
+        currencyId: "ton",
+        seedIdentifier: PUBKEY,
+        name: "TON 1",
+        derivationMode: "ton",
+        index: 0,
+        freshAddress: ADDRESS,
+        freshAddressPath: PATH,
+        xpub: PUBKEY,
+        blockHeight: 0,
+        operations: [],
+        pendingOperations: [],
+        lastSyncDate: "",
+        balance: "5000000000",
+        subAccounts: [],
+      },
+      transactions: [
+        {
+          name: "Not a valid address",
+          transaction: fromTransactionRaw({
+            family: "ton",
+            recipient: "novalidaddress",
+            fees: "10000000",
+            amount: "1000",
+            comment: { isEncrypted: false, text: "" },
+          }),
+          expectedStatus: {
+            errors: {
+              recipient: new InvalidAddress(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "Not enough balance",
+          transaction: fromTransactionRaw({
+            family: "ton",
+            recipient: ADDRESS_2,
+            fees: "10000000",
+            amount: (300 * 1e9).toString(),
+            comment: { isEncrypted: false, text: "" },
+          }),
+          expectedStatus: {
+            errors: {
+              amount: new NotEnoughBalance(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "Invalid transferID/Memo",
+          transaction: fromTransactionRaw({
+            family: "ton",
+            recipient: ADDRESS_2,
+            fees: "10000000",
+            amount: (1 * 1e9).toString(),
+            comment: { isEncrypted: false, text: "😀" },
+          }),
+          expectedStatus: {
+            errors: {
+              comment: new TonCommentInvalid(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "New account and sufficient amount",
+          transaction: fromTransactionRaw({
+            family: "ton",
+            recipient: ADDRESS_2,
+            fees: "10000000",
+            amount: "10000000",
+            comment: { isEncrypted: false, text: "Valid" },
+          }),
+          expectedStatus: {
+            amount: new BigNumber("10000000"),
+            errors: {},
+            warnings: {},
+          },
+        },
+      ],
+    },
+  ],
+};
+
+export const dataset: DatasetTest<Transaction> = {
+  implementations: ["js"],
+  currencies: {
+    ton,
+  },
+};
+
+/**
+ * NOTE: if tests are added to this file,
+ * like done in libs/coin-polkadot/src/bridge.integration.test.ts for example,
+ * this file fill need to be imported in ledger-live-common
+ * libs/ledger-live-common/src/families/ton/bridge.integration.test.ts
+ * like done for polkadot.
+ * cf.
+ * - libs/coin-polkadot/src/bridge.integration.test.ts
+ * - libs/ledger-live-common/src/families/polkadot/bridge.integration.test.ts
+ */

package/src/__tests__/unit/api.unit.test.ts

@@ -0,0 +1,60 @@
+import {
+  estimateFee,
+  fetchAccountInfo,
+  fetchLastBlockNumber,
+  fetchTransactions,
+} from "../../bridge/bridgeHelpers/api";
+import { setCoinConfig } from "../../config";
+import mockServer, { API_TON_ENDPOINT } from "../fixtures/api.fixtures";
+import {
+  lastBlockNumber,
+  mockAddress,
+  tonAccount,
+  tonEstimateFee,
+  tonTransactionResponse,
+  tonWallet,
+} from "../fixtures/common.fixtures";
+
+describe("getAccount", () => {
+  beforeAll(() => {
+    setCoinConfig(() => ({
+      status: {
+        type: "active",
+      },
+      infra: {
+        API_TON_ENDPOINT: API_TON_ENDPOINT,
+      },
+    }));
+    mockServer.listen();
+  });
+
+  afterAll(() => {
+    mockServer.close();
+  });
+
+  it("should return last block number", async () => {
+    const result = await fetchLastBlockNumber();
+    expect(result).toEqual(lastBlockNumber.last.seqno);
+  });
+
+  it("should return the transactions of an address", async () => {
+    const result = await fetchTransactions(mockAddress);
+    expect(result).toEqual(tonTransactionResponse);
+  });
+
+  it("should return the ton account info of an address", async () => {
+    const result = await fetchAccountInfo(mockAddress);
+    expect(result).toEqual({
+      balance: tonAccount.balance,
+      last_transaction_lt: tonAccount.last_transaction_lt,
+      last_transaction_hash: tonAccount.last_transaction_hash,
+      status: tonAccount.status,
+      seqno: tonWallet.seqno,
+    });
+  });
+
+  it("should return the estimated fees", async () => {
+    const result = await estimateFee(mockAddress, "");
+    expect(result).toEqual(tonEstimateFee.source_fees);
+  });
+});

package/src/__tests__/unit/broadcast.unit.test.ts

@@ -0,0 +1,36 @@
+import { encodeOperationId } from "@ledgerhq/coin-framework/lib/operation";
+import { broadcastTx } from "../../bridge/bridgeHelpers/api";
+import broadcast from "../../broadcast";
+import { buildOptimisticOperation } from "../../signOperation";
+import { account, transaction } from "../fixtures/common.fixtures";
+
+jest.mock("../../bridge/bridgeHelpers/api");
+const mockedHash = "validHash";
+
+describe("broadcast", () => {
+  beforeAll(() => {
+    const broadcastTxMock = jest.mocked(broadcastTx);
+    broadcastTxMock.mockReturnValue(Promise.resolve(mockedHash));
+  });
+
+  it("should broadcast the coin transaction and add the hash in the optimistic transaction", async () => {
+    const optimisticCoinOperation = buildOptimisticOperation(account, transaction);
+
+    const finalOperation = await broadcast({
+      account,
+      signedOperation: {
+        operation: optimisticCoinOperation,
+        signature: "0xS1gn4tUR3",
+      },
+    });
+
+    expect(broadcastTx).toHaveBeenCalled();
+    expect(finalOperation).toEqual({
+      ...optimisticCoinOperation,
+      id: encodeOperationId(account.id, mockedHash, "OUT"),
+      hash: mockedHash,
+      subOperations: [],
+      nftOperations: [],
+    });
+  });
+});

package/src/__tests__/unit/createTransaction.unit.test.ts

@@ -0,0 +1,20 @@
+import BigNumber from "bignumber.js";
+import createTransaction from "../../createTransaction";
+import { account } from "../fixtures/common.fixtures";
+
+describe("createTransaction", () => {
+  it("should create a valid transaction", async () => {
+    const res = createTransaction(account);
+    expect(res).toEqual({
+      family: "ton",
+      amount: new BigNumber(0),
+      fees: new BigNumber(0),
+      recipient: "",
+      useAllAmount: false,
+      comment: {
+        isEncrypted: false,
+        text: "",
+      },
+    });
+  });
+});

package/src/__tests__/unit/deviceTransactionConfig.unit.test.ts

@@ -0,0 +1,69 @@
+import BigNumber from "bignumber.js";
+import getDeviceTransactionConfig from "../../deviceTransactionConfig";
+import { account, transaction as baseTransaction } from "../fixtures/common.fixtures";
+
+const status = {
+  errors: {},
+  warnings: {},
+  estimatedFees: new BigNumber(0),
+  amount: new BigNumber(0),
+  totalSpent: new BigNumber(0),
+};
+
+describe("deviceTransactionConfig", () => {
+  describe("TON transaction", () => {
+    it("should return the fields for a transaction when there is a valid comment", async () => {
+      const transaction = {
+        ...baseTransaction,
+        comment: { isEncrypted: false, text: "validComment" },
+      };
+      const res = await getDeviceTransactionConfig({
+        account: account,
+        parentAccount: undefined,
+        transaction,
+        status,
+      });
+      expect(res).toEqual([
+        {
+          type: "address",
+          label: "To",
+          address: transaction.recipient,
+        },
+        {
+          type: "amount",
+          label: "Amount",
+        },
+        { type: "fees", label: "Fee" },
+        { type: "text", label: "Comment", value: "validComment" },
+      ]);
+    });
+
+    it("should return the fields for a transaction when useAllAmount is true and there is a valid comment", async () => {
+      const transaction = {
+        ...baseTransaction,
+        useAllAmount: true,
+        comment: { isEncrypted: false, text: "validComment" },
+      };
+      const res = await getDeviceTransactionConfig({
+        account: account,
+        parentAccount: undefined,
+        transaction,
+        status,
+      });
+      expect(res).toEqual([
+        {
+          type: "address",
+          label: "To",
+          address: transaction.recipient,
+        },
+        {
+          type: "text",
+          label: "Amount",
+          value: "ALL YOUR TONs",
+        },
+        { type: "fees", label: "Fee" },
+        { type: "text", label: "Comment", value: "validComment" },
+      ]);
+    });
+  });
+});

package/src/__tests__/unit/estimateMaxSpendable.unit.test.ts

@@ -0,0 +1,19 @@
+import { estimateFee, fetchAccountInfo } from "../../bridge/bridgeHelpers/api";
+import estimateMaxSpendable from "../../estimateMaxSpendable";
+import { account, accountInfo, fees, totalFees, transaction } from "../fixtures/common.fixtures";
+
+jest.mock("../../bridge/bridgeHelpers/api");
+
+describe("estimateMaxSpendable", () => {
+  beforeAll(() => {
+    const fetchAccountInfoMock = jest.mocked(fetchAccountInfo);
+    fetchAccountInfoMock.mockReturnValue(Promise.resolve(accountInfo));
+    const fetchEstimateFeeMock = jest.mocked(estimateFee);
+    fetchEstimateFeeMock.mockReturnValue(Promise.resolve(fees));
+  });
+
+  it("should return the max spendable for a TON transaction", async () => {
+    const res = await estimateMaxSpendable({ account, transaction });
+    expect(res).toEqual(account.balance.minus(totalFees));
+  });
+});

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

@@ -0,0 +1,119 @@
+import {
+  AmountRequired,
+  InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalance,
+  RecipientRequired,
+} from "@ledgerhq/errors";
+import BigNumber from "bignumber.js";
+import { TonCommentInvalid } from "../../errors";
+import getTransactionStatus from "../../getTransactionStatus";
+import { account, transaction as baseTransaction } from "../fixtures/common.fixtures";
+
+describe("getTransactionStatus", () => {
+  describe("Recipient", () => {
+    it("should detect the missing recipient and have an error", async () => {
+      const transaction = { ...baseTransaction, recipient: "" };
+      const res = await getTransactionStatus(account, transaction);
+      expect(res.errors).toEqual(
+        expect.objectContaining({
+          recipient: new RecipientRequired(),
+        }),
+      );
+    });
+
+    it("should detect the incorrect recipient and have an error", async () => {
+      const transaction = { ...baseTransaction, recipient: "isInvalid" };
+      const res = await getTransactionStatus(account, transaction);
+      expect(res.errors).toEqual(
+        expect.objectContaining({
+          recipient: new InvalidAddress("", {
+            currencyName: account.currency.name,
+          }),
+        }),
+      );
+    });
+
+    it("should detect the recipient and the sender are the same and have an error", async () => {
+      const transaction = {
+        ...baseTransaction,
+        recipient: "UQDzd8aeBOU-jqYw_ZSuZjceI5p-F4b7HMprAsUJAtRPbMol",
+      };
+      const res = await getTransactionStatus(account, transaction);
+      expect(res.errors).toEqual(
+        expect.objectContaining({
+          recipient: new InvalidAddressBecauseDestinationIsAlsoSource("", {
+            currencyName: account.currency.name,
+          }),
+        }),
+      );
+    });
+  });
+
+  describe("Sender", () => {
+    it("should detect the sender is not correct and have an error", async () => {
+      const tempAccount = { ...account, freshAddress: "isInvalid" };
+      const res = await getTransactionStatus(tempAccount, baseTransaction);
+      expect(res.errors).toEqual(
+        expect.objectContaining({
+          sender: new InvalidAddress(),
+        }),
+      );
+    });
+  });
+
+  describe("Amount", () => {
+    it("should detect the amount is missing and have an error", async () => {
+      const transaction = { ...baseTransaction, amount: new BigNumber(0) };
+      const res = await getTransactionStatus(account, transaction);
+      expect(res.errors).toEqual(
+        expect.objectContaining({
+          amount: new AmountRequired(),
+        }),
+      );
+    });
+
+    it("should detect the amount is greater than the spendable amount and have an error", async () => {
+      const transaction = {
+        ...baseTransaction,
+        amount: BigNumber(1000000002),
+        fees: new BigNumber("20"),
+      };
+      const res = await getTransactionStatus(account, transaction);
+      expect(res.errors).toEqual(
+        expect.objectContaining({
+          amount: new NotEnoughBalance(),
+        }),
+      );
+    });
+
+    describe("Comment", () => {
+      it("should detect the comment is not valid and have an error", async () => {
+        const transaction = {
+          ...baseTransaction,
+          comment: { isEncrypted: false, text: "comment\nInvalid" },
+        };
+        const res = await getTransactionStatus(account, transaction);
+        expect(res.errors).toEqual(
+          expect.objectContaining({
+            transaction: new TonCommentInvalid(),
+          }),
+        );
+      });
+    });
+
+    describe("Successful transaction", () => {
+      it("should not have errors", async () => {
+        const successfulResult = {
+          amount: baseTransaction.amount,
+          errors: {},
+          warnings: {},
+          estimatedFees: baseTransaction.fees,
+          totalSpent: baseTransaction.amount.plus(baseTransaction.fees),
+        };
+        const res = await getTransactionStatus(account, baseTransaction);
+        expect(res).toEqual(successfulResult);
+      });
+    });
+  });
+});

package/src/__tests__/unit/hw-getAddress.unit.test.ts

@@ -0,0 +1,58 @@
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
+import resolver from "../../hw-getAddress";
+import { TonSigner } from "../../signer";
+import { getLedgerTonPath } from "../../utils";
+
+const address = "0xc3f95102d5c8f2c83e49ce3acfb905edfb7f37de";
+const publicKey = "mockedPublicKey";
+const spyGetAddress = jest.fn().mockImplementation(async () =>
+  Promise.resolve({
+    publicKey,
+    address: address.toLowerCase(),
+  }),
+);
+const spyValidateAddress = jest.fn().mockImplementation(async () =>
+  Promise.resolve({
+    publicKey,
+    address: address.toLowerCase(),
+  }),
+);
+
+const mockSignerFactory = <T>(_: string, fn: (signer: TonSigner) => Promise<T>): Promise<T> =>
+  fn({
+    getAddress: spyGetAddress,
+    validateAddress: spyValidateAddress,
+    signTransaction: jest.fn(),
+  });
+
+describe("hw-getAddress", () => {
+  it("should return an encoded address and a public key when verifiy is false", async () => {
+    const getAddress = resolver(mockSignerFactory);
+    const response = await getAddress("deviceId", {
+      path: "44'/607'/0'/0'/0'/0'",
+      verify: false,
+      currency: getCryptoCurrencyById("ton"),
+      derivationMode: "ton",
+    });
+    expect(response.address).toBe(address);
+    expect(response.publicKey).toBe(publicKey);
+    expect(spyGetAddress).toHaveBeenCalledWith(getLedgerTonPath("44'/607'/0'/0'/0'/0'"), {
+      bounceable: false,
+    });
+  });
+
+  it("should return an encoded address and a public key when verifiy is true", async () => {
+    const getAddress = resolver(mockSignerFactory);
+    const response = await getAddress("deviceId", {
+      path: "44'/607'/0'/0'/0'/0'",
+      verify: true,
+      currency: getCryptoCurrencyById("ton"),
+      derivationMode: "ton",
+    });
+    expect(response.address).toBe(address);
+    expect(response.publicKey).toBe(publicKey);
+    expect(spyValidateAddress).toHaveBeenCalledWith(getLedgerTonPath("44'/607'/0'/0'/0'/0'"), {
+      bounceable: false,
+    });
+  });
+});