@ledgerhq/coin-ton 0.3.12-next.0

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

@@ -0,0 +1,52 @@
+import { estimateFee, fetchAccountInfo } from "../../bridge/bridgeHelpers/api";
+import prepareTransaction from "../../prepareTransaction";
+import {
+  account,
+  accountInfo,
+  transaction as baseTransaction,
+  fees,
+  totalFees,
+} from "../fixtures/common.fixtures";
+
+jest.mock("../../bridge/bridgeHelpers/api");
+
+describe("prepareTransaction", () => {
+  beforeAll(() => {
+    const fetchAccountInfoMock = jest.mocked(fetchAccountInfo);
+    fetchAccountInfoMock.mockReturnValue(Promise.resolve(accountInfo));
+    const fetchEstimateFeeMock = jest.mocked(estimateFee);
+    fetchEstimateFeeMock.mockReturnValue(Promise.resolve(fees));
+  });
+
+  describe("Ton Transaction", () => {
+    it("should return the transaction with the updated amount and fees", async () => {
+      const transaction = await prepareTransaction(account, baseTransaction);
+
+      expect(transaction).toEqual({
+        ...baseTransaction,
+        fees: totalFees,
+      });
+    });
+
+    it("should preserve the reference when no change is detected on the transaction", async () => {
+      const transaction = await prepareTransaction(account, { ...baseTransaction });
+      const transaction2 = await prepareTransaction(account, transaction);
+
+      expect(transaction).toBe(transaction2);
+    });
+
+    it("should create a coin transaction using the spendableBalance in the account", async () => {
+      const transaction = await prepareTransaction(account, {
+        ...baseTransaction,
+        useAllAmount: true,
+      });
+
+      expect(transaction).toEqual({
+        ...baseTransaction,
+        useAllAmount: true,
+        fees: totalFees,
+        amount: account.spendableBalance.minus(totalFees),
+      });
+    });
+  });
+});

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

@@ -0,0 +1,90 @@
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { Address, Cell, beginCell, storeMessage } from "@ton/core";
+import BigNumber from "bignumber.js";
+import { fetchAccountInfo } from "../../bridge/bridgeHelpers/api";
+import { buildSignOperation } from "../../signOperation";
+import { TonSigner } from "../../signer";
+import { account, accountInfo, totalFees, transaction } from "../fixtures/common.fixtures";
+
+jest.mock("../../bridge/bridgeHelpers/api");
+
+const spySignTransaction = jest.fn().mockImplementation(async () =>
+  Promise.resolve(
+    beginCell()
+      .store(
+        storeMessage({
+          info: {
+            type: "external-in",
+            dest: Address.parse("EQDzd8aeBOU-jqYw_ZSuZjceI5p-F4b7HMprAsUJAtRPbJfg"),
+            importFee: BigInt(0),
+          },
+          body: new Cell(),
+        }),
+      )
+      .endCell(),
+  ),
+);
+
+const mockSignerContext: SignerContext<TonSigner> = <T>(
+  _: string,
+  fn: (signer: TonSigner) => Promise<T>,
+) => {
+  return fn({
+    signTransaction: spySignTransaction,
+    getAddress: jest.fn(),
+    validateAddress: jest.fn(),
+  });
+};
+
+describe("signOperation", () => {
+  beforeAll(() => {
+    const fetchAccountInfoMock = jest.mocked(fetchAccountInfo);
+    fetchAccountInfoMock.mockReturnValue(Promise.resolve(accountInfo));
+  });
+
+  it("should return an optimistic operation and a signed hash returned by the app bindings", done => {
+    const signOperation = buildSignOperation(mockSignerContext);
+
+    const signOpObservable = signOperation({
+      account,
+      transaction: { ...transaction, fees: totalFees },
+      deviceId: "",
+    });
+
+    signOpObservable.subscribe(obs => {
+      if (obs.type === "signed") {
+        const {
+          signedOperation: { signature, operation },
+        } = obs;
+
+        const { amount } = transaction;
+
+        expect(operation).toEqual({
+          id: "",
+          hash: "",
+          type: "OUT",
+          value: new BigNumber(amount).plus(totalFees),
+          fee: totalFees,
+          blockHash: null,
+          blockHeight: null,
+          senders: [account.freshAddress],
+          recipients: [transaction.recipient],
+          accountId: account.id,
+          date: expect.any(Date),
+          extra: {
+            comment: {
+              isEncrypted: false,
+              text: "",
+            },
+            explorerHash: "",
+            lt: "",
+          },
+        });
+        expect(signature).toBe(
+          "te6cckEBAQEASAAAi4gB5u+NPAnKfR1MYfspXMxuPEc0/C8N9jmU1gWKEgWontgEQA83fGngTlPo6mMP2UrmY3HiOafheG+xzKawLFCQLUT2wCDSMh+F",
+        );
+        done();
+      }
+    });
+  });
+});

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

@@ -0,0 +1,121 @@
+import { encodeOperationId } from "@ledgerhq/coin-framework/lib/operation";
+import BigNumber from "bignumber.js";
+// eslint-disable-next-line no-restricted-imports
+import { flatMap } from "lodash";
+import { TonTransaction } from "../../bridge/bridgeHelpers/api.types";
+import { mapTxToOps } from "../../bridge/bridgeHelpers/txn";
+import { mockAccountId, mockAddress, tonTransactionResponse } from "../fixtures/common.fixtures";
+
+describe("Transaction functions", () => {
+  describe("mapTxToOps", () => {
+    it.skip("should map an IN ton transaction without total_fees to a ledger operation", async () => {
+      const { now, lt, hash, in_msg, total_fees, mc_block_seqno } =
+        tonTransactionResponse.transactions[0];
+
+      const finalOperation = flatMap(
+        tonTransactionResponse.transactions,
+        mapTxToOps(mockAccountId, mockAddress, tonTransactionResponse.address_book),
+      );
+
+      expect(finalOperation).toEqual([
+        {
+          accountId: mockAccountId,
+          blockHash: null,
+          blockHeight: mc_block_seqno,
+          date: new Date(now * 1000), // now is defined in seconds
+          extra: { comment: { isEncrypted: false, text: "" }, explorerHash: hash, lt },
+          fee: BigNumber(total_fees),
+          hasFailed: false,
+          hash: in_msg?.hash,
+          id: encodeOperationId(mockAccountId, in_msg?.hash ?? "", "IN"),
+          recipients: [in_msg?.destination],
+          senders: ["EQCVnqqL0OOiZi2BQnjVGm-ZeUYgfUhHgAi-vn9F8-94HwrH"],
+          type: "IN",
+          value: BigNumber(in_msg?.value ?? 0),
+        },
+      ]);
+    });
+
+    it.skip("should map an IN ton transaction with total_fees to a ledger operation", async () => {
+      const transactions = [{ ...tonTransactionResponse.transactions[0], total_fees: "15" }];
+      const { now, lt, hash, in_msg, total_fees, mc_block_seqno, account } = transactions[0];
+
+      const finalOperation = flatMap(
+        transactions,
+        mapTxToOps(mockAccountId, mockAddress, tonTransactionResponse.address_book),
+      );
+
+      expect(finalOperation).toEqual([
+        {
+          id: encodeOperationId(mockAccountId, in_msg?.hash ?? "", "NONE"),
+          hash: in_msg?.hash,
+          type: "NONE",
+          value: BigNumber(total_fees),
+          fee: BigNumber(0),
+          blockHash: null,
+          blockHeight: mc_block_seqno,
+          hasFailed: false,
+          accountId: mockAccountId,
+          senders: [account],
+          recipients: [],
+          date: new Date(now * 1000), // now is defined in seconds
+          extra: { comment: { isEncrypted: false, text: "" }, explorerHash: hash, lt },
+        },
+        {
+          accountId: mockAccountId,
+          blockHash: null,
+          blockHeight: mc_block_seqno,
+          date: new Date(now * 1000), // now is defined in seconds
+          extra: { comment: { isEncrypted: false, text: "" }, explorerHash: hash, lt },
+          fee: BigNumber(total_fees),
+          hasFailed: false,
+          hash: in_msg?.hash,
+          id: encodeOperationId(mockAccountId, in_msg?.hash ?? "", "IN"),
+          recipients: [in_msg?.destination],
+          senders: ["EQCVnqqL0OOiZi2BQnjVGm-ZeUYgfUhHgAi-vn9F8-94HwrH"],
+          type: "IN",
+          value: BigNumber(in_msg?.value ?? 0),
+        },
+      ]);
+    });
+
+    it.skip("should map an OUT ton transaction to a ledger operation", async () => {
+      // The IN transaction will be used as OUT transaction and it will be adjusted
+      const transactions: TonTransaction[] = [
+        {
+          ...tonTransactionResponse.transactions[0],
+          in_msg: null,
+        },
+      ];
+      if (tonTransactionResponse.transactions[0].in_msg) {
+        transactions[0].out_msgs = [
+          { ...tonTransactionResponse.transactions[0].in_msg, source: transactions[0].account },
+        ];
+      }
+      const { now, lt, hash, out_msgs, total_fees, mc_block_seqno, account } = transactions[0];
+
+      const finalOperation = flatMap(
+        transactions,
+        mapTxToOps(mockAccountId, mockAddress, tonTransactionResponse.address_book),
+      );
+
+      expect(finalOperation).toEqual([
+        {
+          id: encodeOperationId(mockAccountId, hash ?? "", "OUT"),
+          hash: out_msgs?.[0].hash,
+          type: "OUT",
+          value: BigNumber(out_msgs[0].value ?? 0).plus(BigNumber(total_fees)),
+          fee: BigNumber(total_fees),
+          blockHeight: mc_block_seqno,
+          blockHash: null,
+          hasFailed: false,
+          accountId: mockAccountId,
+          senders: [account],
+          recipients: ["EQDzd8aeBOU-jqYw_ZSuZjceI5p-F4b7HMprAsUJAtRPbJfg"],
+          date: new Date(now * 1000), // now is defined in seconds
+          extra: { comment: { isEncrypted: false, text: "" }, explorerHash: hash, lt },
+        },
+      ]);
+    });
+  });
+});

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

@@ -0,0 +1,126 @@
+import { Address } from "@ton/core";
+import { TonComment } from "../../types";
+import {
+  addressesAreEqual,
+  buildTonTransaction,
+  commentIsValid,
+  getLedgerTonPath,
+  getTransferExpirationTime,
+  isAddressValid,
+} from "../../utils";
+import { transaction as baseTransaction } from "../fixtures/common.fixtures";
+
+describe("TON addresses", () => {
+  const addr = {
+    raw: "0:074c7194d64e8218f2cfaab8e79b34201adbed0f8fa7f2773e604dd39969b5ff",
+    rawWrong: "0:074c7194d64e8218f2cfaab8e79b34201adbed0f8fa7f2773e604dd39969b5f",
+    bounceUrl: "EQAHTHGU1k6CGPLPqrjnmzQgGtvtD4-n8nc-YE3TmWm1_1JZ",
+    bounceNoUrl: "EQAHTHGU1k6CGPLPqrjnmzQgGtvtD4+n8nc+YE3TmWm1/1JZ",
+    bounceWrong: "EQAHTHGU1k6CGPLPqrjnmzQgGtvtD4+n8nc+YE3TmWm1/1J",
+    noBounceUrl: "UQAHTHGU1k6CGPLPqrjnmzQgGtvtD4-n8nc-YE3TmWm1_w-c",
+    noBounceNoUrl: "UQAHTHGU1k6CGPLPqrjnmzQgGtvtD4+n8nc+YE3TmWm1/w+c",
+    noBounceWrong: "UQAHTHGU1k6CGPLPqrjnmzQgGtvtD4+n8nc+YE3TmWm1/w+",
+    diff: "UQBjrXgZbYDCpxLKpgMnBe985kYDfUeriuYUafbuKgdBpWuJ",
+  };
+  test("Check if addresses are valid", () => {
+    expect(isAddressValid(addr.raw)).toBe(true);
+    expect(isAddressValid(addr.bounceUrl)).toBe(true);
+    expect(isAddressValid(addr.bounceNoUrl)).toBe(true);
+    expect(isAddressValid(addr.noBounceUrl)).toBe(true);
+    expect(isAddressValid(addr.noBounceNoUrl)).toBe(true);
+    expect(isAddressValid(addr.rawWrong)).toBe(false);
+    expect(isAddressValid(addr.bounceWrong)).toBe(false);
+    expect(isAddressValid(addr.noBounceWrong)).toBe(false);
+    expect(isAddressValid(addr.diff)).toBe(true);
+  });
+  test("Compare addresses", () => {
+    expect(addressesAreEqual(addr.raw, addr.bounceUrl)).toBe(true);
+    expect(addressesAreEqual(addr.raw, addr.noBounceUrl)).toBe(true);
+    expect(addressesAreEqual(addr.bounceUrl, addr.noBounceUrl)).toBe(true);
+    expect(addressesAreEqual(addr.rawWrong, addr.noBounceUrl)).toBe(false);
+    expect(addressesAreEqual(addr.noBounceNoUrl, addr.diff)).toBe(false);
+  });
+});
+
+test("TON Comments are valid", () => {
+  const msg = (e: boolean, m: string): TonComment => ({ isEncrypted: e, text: m });
+  expect(commentIsValid(msg(false, ""))).toBe(true);
+  expect(commentIsValid(msg(false, "Hello world!"))).toBe(true);
+  expect(
+    commentIsValid(
+      msg(
+        false,
+        " 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789", // 120 chars
+      ),
+    ),
+  ).toBe(true);
+  expect(
+    commentIsValid(
+      msg(
+        false,
+        " 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789 ", // 121 chars
+      ),
+    ),
+  ).toBe(false);
+  expect(commentIsValid(msg(false, "😀"))).toBe(false);
+  expect(commentIsValid(msg(true, ""))).toBe(false);
+});
+
+describe("Get TON paths", () => {
+  const correctPath = ["44'/607'/0'/0'/0'/0'", "m/44'/607'/0'/0'/0'/0'"];
+  const wrongPaths = [
+    "44'/607'/0'/0'/0'",
+    "44'/607'/0'/0/'/0'",
+    "44'/607'/0'/0'/x'/0'",
+    "44'/607'/0'/-3'/0'/0'",
+    "44'/607'/0'/2147483650'/0'/0'",
+  ];
+
+  test("Correct paths return a correct response", () => {
+    correctPath.map((path: string) => {
+      expect(getLedgerTonPath(path)).toStrictEqual([44, 607, 0, 0, 0, 0]);
+    });
+  });
+
+  test("Wrong paths fail", () => {
+    wrongPaths.map((path: string) => {
+      expect(() => getLedgerTonPath(path)).toThrow(/^(\[ton\] Path)/);
+    });
+  });
+});
+
+describe("Build TON transaction", () => {
+  const seqno = 22;
+
+  test("Build TON transaction with an specific amount", () => {
+    const tonTransaction = buildTonTransaction(baseTransaction, seqno);
+
+    // Convert the Address to string to compare
+    expect({ ...tonTransaction, to: tonTransaction.to.toString() }).toEqual({
+      to: Address.parse(baseTransaction.recipient).toString(),
+      seqno,
+      amount: BigInt(baseTransaction.amount.toString()),
+      bounce: false,
+      timeout: getTransferExpirationTime(),
+      sendMode: 3,
+    });
+  });
+
+  test("Build TON transaction when useAllAmount is true and there is a comment", () => {
+    const transaction = { ...baseTransaction };
+    transaction.useAllAmount = true;
+    transaction.comment.text = "valid coment";
+    const tonTransaction = buildTonTransaction(transaction, seqno);
+
+    // Convert the Address to string to compare
+    expect({ ...tonTransaction, to: tonTransaction.to.toString() }).toEqual({
+      to: Address.parse(transaction.recipient).toString(),
+      seqno,
+      amount: BigInt(0),
+      bounce: false,
+      timeout: getTransferExpirationTime(),
+      sendMode: 128,
+      payload: { type: "comment", text: transaction.comment.text },
+    });
+  });
+});

package/src/bridge/bridgeHelpers/api.ts

@@ -0,0 +1,104 @@
+import network from "@ledgerhq/live-network";
+import { Address } from "@ton/ton";
+import { getCoinConfig } from "../../config";
+import {
+  TonAccountInfo,
+  TonFee,
+  TonResponseAccountInfo,
+  TonResponseEstimateFee,
+  TonResponseMasterchainInfo,
+  TonResponseMessage,
+  TonResponseWalletInfo,
+  TonTransactionsList,
+} from "./api.types";
+
+const getTonUrl = (path?: string): string => {
+  const currencyConfig = getCoinConfig();
+
+  return `${currencyConfig.infra.API_TON_ENDPOINT}${path ?? ""}`;
+};
+
+const fetch = async <T>(path: string): Promise<T> => {
+  const url = getTonUrl(path);
+
+  const { data } = await network<T>({
+    method: "GET",
+    url,
+  });
+
+  return data;
+};
+
+const send = async <T>(path: string, data: Record<string, unknown>) => {
+  const url = getTonUrl(path);
+
+  const { data: dataResponse } = await network<T>({
+    method: "POST",
+    url,
+    data: JSON.stringify(data),
+    headers: { "Content-Type": "application/json" },
+  });
+
+  return dataResponse;
+};
+
+export async function fetchLastBlockNumber(): Promise<number> {
+  const data = await fetch<TonResponseMasterchainInfo>("/masterchainInfo");
+  return data.last.seqno;
+}
+
+export async function fetchTransactions(
+  addr: string,
+  opts?: { startLt?: string; endLt?: string },
+): Promise<TonTransactionsList> {
+  const address = Address.parse(addr);
+  const urlAddr = address.toString({ bounceable: false, urlSafe: true });
+  let url = `/transactions?account=${urlAddr}&limit=256`;
+  if (opts?.startLt != null) url += `&start_lt=${opts.startLt}`;
+  if (opts?.endLt != null) url += `&end_lt=${opts.endLt}`;
+  return await fetch<TonTransactionsList>(url);
+}
+
+export async function fetchAccountInfo(addr: string): Promise<TonAccountInfo> {
+  const address = Address.parse(addr);
+  const urlAddr = address.toString({ bounceable: false, urlSafe: true });
+  const data = await fetch<TonResponseAccountInfo>(`/account?address=${urlAddr}`);
+  if (data.status === "uninit" || data.status === "nonexist") {
+    return {
+      balance: data.balance,
+      last_transaction_lt: data.last_transaction_lt,
+      last_transaction_hash: data.last_transaction_hash,
+      status: data.status,
+      seqno: 0,
+    };
+  }
+  const { seqno } = await fetch<TonResponseWalletInfo>(`/wallet?address=${urlAddr}`);
+  return {
+    balance: data.balance,
+    last_transaction_lt: data.last_transaction_lt,
+    last_transaction_hash: data.last_transaction_hash,
+    status: data.status,
+    seqno: seqno || 0,
+  };
+}
+
+export async function estimateFee(
+  address: string,
+  body: string,
+  initCode?: string,
+  initData?: string,
+): Promise<TonFee> {
+  return (
+    await send<TonResponseEstimateFee>("/estimateFee", {
+      address,
+      body,
+      init_code: initCode,
+      init_data: initData,
+      ignore_chksig: true,
+    })
+  ).source_fees;
+}
+
+export async function broadcastTx(bocBase64: string): Promise<string> {
+  return (await send<TonResponseMessage>("/message", { boc: bocBase64 })).message_hash;
+}

package/src/bridge/bridgeHelpers/api.types.ts

@@ -0,0 +1,178 @@
+type TonAccountStatus = "uninit" | "frozen" | "active" | "nonexist";
+
+interface TonAccountState {
+  hash: string;
+  balance: string | null;
+  account_status: TonAccountStatus | null;
+  frozen_hash: string | null;
+  code_hash: string | null;
+  data_hash: string | null;
+}
+
+interface TonMessage {
+  hash: string;
+  source: string | null;
+  destination: string | null;
+  value: string | null;
+  fwd_fee: string | null;
+  ihr_fee: string | null;
+  created_lt: string | null;
+  created_at: string | null;
+  opcode: string | null;
+  ihr_disabled: boolean | null;
+  bounce: boolean | null;
+  bounced: boolean | null;
+  import_fee: string | null;
+  message_content: {
+    hash: string;
+    body: string;
+    decoded:
+      | {
+          type: "text_comment";
+          comment: string;
+        }
+      | {
+          type: "binary_comment";
+          hex_comment: string;
+        }
+      | null;
+  } | null;
+  init_state: { hash: string; body: string } | null;
+}
+
+interface BlockReference {
+  workchain: number;
+  shard: string;
+  seqno: number;
+}
+
+interface TonBlock {
+  workchain: number;
+  shard: string;
+  seqno: number;
+  root_hash: string;
+  file_hash: string;
+  global_id: number;
+  version: number;
+  after_merge: boolean;
+  before_split: boolean;
+  after_split: boolean;
+  want_merge: boolean;
+  want_split: boolean;
+  key_block: boolean;
+  vert_seqno_incr: boolean;
+  flags: number;
+  gen_utime: string;
+  start_lt: string;
+  end_lt: string;
+  validator_list_hash_short: number;
+  gen_catchain_seqno: number;
+  min_ref_mc_seqno: number;
+  prev_key_block_seqno: number;
+  vert_seqno: number;
+  master_ref_seqno: number | null;
+  rand_seed: string;
+  created_by: string;
+  tx_count: number | null;
+  masterchain_block_ref: BlockReference | null;
+  prev_blocks: BlockReference[];
+}
+
+interface TrComputePhase {
+  exit_code: number;
+  success: boolean;
+}
+
+interface TonDescription {
+  aborted: boolean;
+  compute_ph: TrComputePhase;
+  credit_first: boolean;
+  storage_ph?: unknown;
+  credit_ph?: unknown;
+  action?: unknown;
+  bounce?: unknown;
+  destroyed: boolean;
+}
+
+export interface TonTransaction {
+  account: string;
+  hash: string;
+  lt: string;
+  now: number;
+  orig_status: TonAccountStatus;
+  end_status: TonAccountStatus;
+  total_fees: string;
+  prev_trans_hash: string;
+  prev_trans_lt: string;
+  description: TonDescription;
+  block_ref: {
+    workchain: number;
+    shard: string;
+    seqno: number;
+  } | null;
+  in_msg: TonMessage | null;
+  out_msgs: TonMessage[];
+  account_state_before: TonAccountState | null;
+  account_state_after: TonAccountState | null;
+  mc_block_seqno: number | null;
+}
+
+export interface TonAddressBook {
+  [key: string]: {
+    user_friendly: string;
+  };
+}
+
+export interface TonAccountInfo {
+  balance: string;
+  last_transaction_lt: string | null;
+  last_transaction_hash: string | null;
+  status: TonAccountStatus;
+  seqno: number;
+}
+
+export interface TonFee {
+  in_fwd_fee: number;
+  storage_fee: number;
+  gas_fee: number;
+  fwd_fee: number;
+}
+
+export interface TonResponseMasterchainInfo {
+  first: TonBlock;
+  last: TonBlock;
+}
+
+export interface TonTransactionsList {
+  transactions: TonTransaction[];
+  address_book: TonAddressBook;
+}
+
+export interface TonResponseAccountInfo {
+  balance: string;
+  code: string | null;
+  data: string | null;
+  last_transaction_lt: string | null;
+  last_transaction_hash: string | null;
+  frozen_hash: string | null;
+  status: TonAccountStatus;
+}
+
+export interface TonResponseWalletInfo {
+  balance: string;
+  wallet_type: string | null;
+  seqno: number | null;
+  wallet_id: number | null;
+  last_transaction_lt: string | null;
+  last_transaction_hash: string | null;
+  status: TonAccountStatus;
+}
+
+export interface TonResponseEstimateFee {
+  source_fees: TonFee;
+  destination_fees: TonFee[];
+}
+
+export interface TonResponseMessage {
+  message_hash: string;
+}