@ledgerhq/coin-ton 0.3.12-next.0

package/src/signOperation.ts

@@ -0,0 +1,115 @@
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import type { Account, AccountBridge, DeviceId, SignOperationEvent } from "@ledgerhq/types-live";
+import { Address, beginCell, external, storeMessage } from "@ton/core";
+import { WalletContractV4 } from "@ton/ton";
+import { Observable } from "rxjs";
+import { fetchAccountInfo } from "./bridge/bridgeHelpers/api";
+import type { TonSigner } from "./signer";
+import type { TonCell, TonOperation, Transaction } from "./types";
+import { buildTonTransaction, getLedgerTonPath } from "./utils";
+
+const packTransaction = (account: Account, needsInit: boolean, signature: TonCell): string => {
+  const { address } = Address.parseFriendly(account.freshAddress);
+  let init: { code: TonCell; data: TonCell } | null = null;
+  if (needsInit) {
+    if (account.xpub?.length !== 64) throw Error("[ton] xpub can't be found");
+    const wallet = WalletContractV4.create({
+      workchain: 0,
+      publicKey: Buffer.from(account.xpub, "hex"),
+    });
+    init = wallet.init;
+  }
+  const ext = external({ to: address, init, body: signature });
+  return beginCell().store(storeMessage(ext)).endCell().toBoc().toString("base64");
+};
+
+/**
+ * Sign Transaction with Ledger hardware
+ */
+export const buildSignOperation =
+  (signerContext: SignerContext<TonSigner>): AccountBridge<Transaction>["signOperation"] =>
+  ({
+    account,
+    transaction,
+    deviceId,
+  }: {
+    account: Account;
+    transaction: Transaction;
+    deviceId: DeviceId;
+  }): Observable<SignOperationEvent> =>
+    new Observable(o => {
+      let cancelled = false;
+      async function main() {
+        const address = account.freshAddress;
+        const accountInfo = await fetchAccountInfo(address);
+
+        const tonTx = buildTonTransaction(transaction, accountInfo.seqno);
+
+        const ledgerPath = getLedgerTonPath(account.freshAddressPath);
+
+        o.next({ type: "device-signature-requested" });
+        const sig = await signerContext(deviceId, signer =>
+          signer.signTransaction(ledgerPath, tonTx),
+        );
+
+        if (cancelled) return;
+
+        o.next({ type: "device-signature-granted" });
+
+        if (!sig) {
+          throw new Error("No signature");
+        }
+
+        const signature = packTransaction(account, accountInfo.status === "uninit", sig);
+
+        const operation = buildOptimisticOperation(account, transaction);
+
+        o.next({
+          type: "signed",
+          signedOperation: {
+            operation,
+            signature,
+          },
+        });
+      }
+
+      main().then(
+        () => o.complete(),
+        e => o.error(e),
+      );
+
+      return () => {
+        cancelled = true;
+      };
+    });
+
+export const buildOptimisticOperation = (
+  account: Account,
+  transaction: Transaction,
+): TonOperation => {
+  const { recipient, amount, fees, comment } = transaction;
+  const { id: accountId } = account;
+
+  const op: TonOperation = {
+    id: "",
+    hash: "",
+    type: "OUT",
+    senders: [account.freshAddress],
+    recipients: [recipient],
+    accountId,
+    value: amount.plus(fees),
+    fee: fees,
+    blockHash: null,
+    blockHeight: null,
+    date: new Date(),
+    extra: {
+      // we don't know yet, will be patched in final operation
+      lt: "",
+      explorerHash: "",
+      comment: comment,
+    },
+  };
+  return op;
+};
+
+export default buildSignOperation;

package/src/signer.ts

@@ -0,0 +1,32 @@
+import { TonCell, TonTransaction } from "./types";
+
+export type TonAddress = {
+  publicKey: Buffer;
+  address: string;
+};
+export type TonSignature = TonCell | undefined;
+export interface TonSigner {
+  getAddress(
+    path: number[],
+    opts?: {
+      testOnly?: boolean;
+      bounceable?: boolean;
+      chain?: number;
+    },
+  ): Promise<{
+    address: string;
+    publicKey: Buffer;
+  }>;
+  validateAddress(
+    path: number[],
+    opts?: {
+      testOnly?: boolean;
+      bounceable?: boolean;
+      chain?: number;
+    },
+  ): Promise<{
+    address: string;
+    publicKey: Buffer;
+  }>;
+  signTransaction: (path: number[], transaction: TonTransaction) => Promise<TonCell>;
+}

package/src/specs.ts

@@ -0,0 +1,122 @@
+import { botTest, pickSiblings } from "@ledgerhq/coin-framework/bot/specs";
+import type { AppSpec, TransactionDestinationTestInput } from "@ledgerhq/coin-framework/bot/types";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets";
+import { DeviceModelId } from "@ledgerhq/devices";
+import BigNumber from "bignumber.js";
+import expect from "expect";
+import invariant from "invariant";
+import { acceptTransaction } from "./speculos-deviceActions";
+import { Transaction } from "./types";
+
+const MIN_SAFE = new BigNumber(1.5e7); // approx two txs' fees (0.015 TON)
+
+export const testDestination = <T>({
+  destination,
+  destinationBeforeTransaction,
+  sendingOperation,
+}: TransactionDestinationTestInput<T>): void => {
+  const amount = sendingOperation.value.minus(sendingOperation.fee);
+  const inOp = destination.operations.find(
+    op => op.hash === sendingOperation.hash && op.type === "IN",
+  );
+  const inFees = inOp?.fee ?? BigNumber(0);
+  botTest("account balance increased with transaction amount", () =>
+    expect(destination.balance.toString()).toBe(
+      destinationBeforeTransaction.balance.plus(amount).minus(inFees).toString(),
+    ),
+  );
+  botTest("operation amount is consistent with sendingOperation", () =>
+    expect({
+      type: inOp?.type,
+      amount: inOp?.value?.toString(),
+    }).toMatchObject({
+      type: "IN",
+      amount: amount.toString(),
+    }),
+  );
+};
+
+const tonSpecs: AppSpec<Transaction> = {
+  name: "TON",
+  currency: getCryptoCurrencyById("ton"),
+  appQuery: {
+    model: DeviceModelId.nanoS,
+    appName: "TON",
+  },
+  genericDeviceAction: acceptTransaction,
+  testTimeout: 6 * 60 * 1000,
+  minViableAmount: MIN_SAFE,
+  transactionCheck: ({ maxSpendable }) => {
+    invariant(maxSpendable.gt(MIN_SAFE), "balance is too low");
+  },
+  mutations: [
+    {
+      name: "Send ~50%",
+      maxRun: 1,
+      testDestination,
+      transaction: ({ account, siblings, bridge, maxSpendable }) => {
+        invariant(maxSpendable.gt(MIN_SAFE), "balance is too low");
+
+        const updates: Array<Partial<Transaction>> = [
+          { recipient: pickSiblings(siblings).freshAddress },
+          { amount: maxSpendable.div(2).integerValue() },
+        ];
+        if (Math.random() < 0.5) updates.push({ comment: { isEncrypted: false, text: "LL Bot" } });
+
+        return {
+          transaction: bridge.createTransaction(account),
+          updates,
+        };
+      },
+
+      test: ({ accountBeforeTransaction, operation, account, transaction }) => {
+        // we don't know the exact amount in fees, so we accept +- 20% of expected fees
+        const baseAmount = accountBeforeTransaction.balance.minus(transaction.amount);
+        const maxBalance = baseAmount.minus(transaction.fees.multipliedBy(0.8).integerValue());
+        const minBalance = baseAmount.minus(transaction.fees.multipliedBy(1.2).integerValue());
+        botTest("account spendable balance decreased with operation", () => {
+          expect(account.spendableBalance.lte(maxBalance)).toBe(true);
+          expect(account.spendableBalance.gte(minBalance)).toBe(true);
+        });
+
+        botTest("operation comment", () =>
+          expect(operation.extra).toMatchObject({
+            comment: transaction.comment,
+          }),
+        );
+      },
+    },
+    {
+      name: "Transfer Max",
+      maxRun: 1,
+      transaction: ({ account, siblings, bridge }) => {
+        const updates: Array<Partial<Transaction>> = [
+          { recipient: pickSiblings(siblings).freshAddress },
+          { useAllAmount: true },
+        ];
+        if (Math.random() < 0.5) updates.push({ comment: { isEncrypted: false, text: "LL Bot" } });
+
+        return {
+          transaction: bridge.createTransaction(account),
+          updates,
+        };
+      },
+      testDestination,
+      test: ({ account, transaction, operation }) => {
+        botTest("account spendable balance is zero", () =>
+          expect(account.spendableBalance.toFixed()).toBe("0"),
+        );
+
+        botTest("operation comment", () =>
+          expect(operation.extra).toMatchObject({
+            comment: transaction.comment,
+          }),
+        );
+      },
+    },
+  ],
+};
+
+export default {
+  tonSpecs,
+};

package/src/speculos-deviceActions.ts

@@ -0,0 +1,38 @@
+import {
+  SpeculosButton,
+  deviceActionFlow,
+  formatDeviceAmount,
+} from "@ledgerhq/coin-framework/bot/specs";
+import type { DeviceAction, State } from "@ledgerhq/coin-framework/bot/types";
+import type { Transaction } from "./types";
+
+export const acceptTransaction: DeviceAction<Transaction, State<Transaction>> = deviceActionFlow({
+  steps: [
+    {
+      title: "Review",
+      button: SpeculosButton.RIGHT,
+    },
+    {
+      title: "To",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction }) => transaction.recipient,
+    },
+    {
+      title: "Amount",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ account, transaction }) =>
+        transaction.useAllAmount
+          ? "ALL YOUR TONs"
+          : formatDeviceAmount(account.currency, transaction.amount),
+    },
+    {
+      title: "Comment",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ transaction }) => transaction.comment.text,
+    },
+    {
+      title: "Approve",
+      button: SpeculosButton.BOTH,
+    },
+  ],
+});

package/src/synchronisation.ts

@@ -0,0 +1,91 @@
+import { decodeAccountId, encodeAccountId } from "@ledgerhq/coin-framework/account/index";
+import { GetAccountShape, makeSync, mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { log } from "@ledgerhq/logs";
+import { Account } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import flatMap from "lodash/flatMap";
+import { fetchAccountInfo, fetchLastBlockNumber } from "./bridge/bridgeHelpers/api";
+import { TonTransactionsList } from "./bridge/bridgeHelpers/api.types";
+import { getTransactions, mapTxToOps } from "./bridge/bridgeHelpers/txn";
+import { TonOperation } from "./types";
+
+export const getAccountShape: GetAccountShape<Account> = async info => {
+  const { address, rest, currency, derivationMode, initialAccount } = info;
+
+  const publicKey = reconciliatePubkey(rest?.publicKey, initialAccount);
+
+  const blockHeight = await fetchLastBlockNumber();
+  const accountId = encodeAccountId({
+    type: "js",
+    version: "2",
+    currencyId: currency.id,
+    xpubOrAddress: publicKey,
+    derivationMode,
+  });
+
+  log("debug", `Generation account shape for ${address}`);
+
+  const newTxs: TonTransactionsList = { transactions: [], address_book: {} };
+  const oldOps = (initialAccount?.operations ?? []) as TonOperation[];
+  const { last_transaction_lt, balance } = await fetchAccountInfo(address);
+  // if last_transaction_lt is empty, then there are no transactions in account
+  if (last_transaction_lt != null) {
+    if (oldOps.length === 0) {
+      const [tmpTxs] = await Promise.all([getTransactions(address)]);
+      newTxs.transactions.push(...tmpTxs.transactions);
+      newTxs.address_book = { ...newTxs.address_book, ...tmpTxs.address_book };
+    } else {
+      // if they are the same, we have no new ops
+      if (oldOps[0].extra.lt !== last_transaction_lt) {
+        const [tmpTxs] = await Promise.all([getTransactions(address, oldOps[0].extra.lt)]);
+        newTxs.transactions.push(...tmpTxs.transactions);
+        newTxs.address_book = { ...newTxs.address_book, ...tmpTxs.address_book };
+      }
+    }
+  }
+
+  const newOps = flatMap(newTxs.transactions, mapTxToOps(accountId, address, newTxs.address_book));
+  const operations = mergeOps(oldOps, newOps);
+
+  const toReturn = {
+    id: accountId,
+    balance: new BigNumber(balance),
+    spendableBalance: new BigNumber(balance),
+    operations,
+    operationsCount: operations.length,
+    blockHeight,
+    xpub: publicKey,
+    lastSyncDate: new Date(),
+  } as Partial<Account>;
+  return toReturn;
+};
+
+const postSync = (initial: Account, synced: Account): Account => {
+  const initialPendingOperations = initial.pendingOperations || [];
+  const { operations } = synced;
+  const pendingOperations = initialPendingOperations.filter(
+    op => !operations.some(o => o.id === op.id),
+  );
+  // Set of hashes from the pending operations of the main account
+  const coinPendingOperationsHashes = new Set();
+  for (const op of pendingOperations) {
+    coinPendingOperationsHashes.add(op.hash);
+  }
+
+  return {
+    ...synced,
+    pendingOperations,
+  };
+};
+
+function reconciliatePubkey(publicKey?: string, initialAccount?: Account): string {
+  if (publicKey?.length === 64) return publicKey;
+  if (initialAccount) {
+    if (initialAccount.xpub?.length === 64) return initialAccount.xpub;
+    const { xpubOrAddress } = decodeAccountId(initialAccount.id);
+    if (xpubOrAddress.length === 64) return xpubOrAddress;
+  }
+  throw Error("[ton] pubkey was not properly restored");
+}
+
+export const sync = makeSync({ getAccountShape, postSync });

package/src/transaction.ts

@@ -0,0 +1,61 @@
+import { getAccountCurrency } from "@ledgerhq/coin-framework/account/index";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+import { formatTransactionStatus } from "@ledgerhq/coin-framework/formatters";
+import {
+  fromTransactionCommonRaw,
+  fromTransactionStatusRawCommon as fromTransactionStatusRaw,
+  toTransactionCommonRaw,
+  toTransactionStatusRawCommon as toTransactionStatusRaw,
+} from "@ledgerhq/coin-framework/serialization";
+import type { Account } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import type { Transaction, TransactionRaw } from "./types";
+
+export const formatTransaction = (
+  { recipient, useAllAmount, amount }: Transaction,
+  account: Account,
+): string => `
+SEND ${
+  useAllAmount
+    ? "MAX"
+    : amount.isZero()
+      ? ""
+      : " " +
+        formatCurrencyUnit(getAccountCurrency(account).units[0], amount, {
+          showCode: true,
+          disableRounding: true,
+        })
+}
+TO ${recipient}`;
+
+export const fromTransactionRaw = (tr: TransactionRaw): Transaction => {
+  const common = fromTransactionCommonRaw(tr);
+
+  return {
+    ...common,
+    family: tr.family,
+    fees: new BigNumber(tr.fees),
+    comment: tr.comment,
+  };
+};
+
+const toTransactionRaw = (transaction: Transaction): TransactionRaw => {
+  const common = toTransactionCommonRaw(transaction);
+
+  return {
+    ...common,
+    family: transaction.family,
+    amount: transaction.amount.toFixed(),
+    fees: transaction.fees.toFixed(),
+    comment: transaction.comment,
+  };
+};
+
+export default {
+  formatTransaction,
+  fromTransactionRaw,
+  toTransactionRaw,
+  fromTransactionStatusRaw,
+  toTransactionStatusRaw,
+  formatTransactionStatus,
+};

package/src/types.ts

@@ -0,0 +1,82 @@
+import {
+  Operation,
+  TransactionCommon,
+  TransactionCommonRaw,
+  TransactionStatusCommon,
+  TransactionStatusCommonRaw,
+} from "@ledgerhq/types-live";
+import { Address, SendMode, StateInit } from "@ton/core";
+import { Cell } from "@ton/ton";
+import BigNumber from "bignumber.js";
+
+type FamilyType = "ton";
+
+// ledger app does not support encrypted comments yet
+// leaving the arch for the future
+export interface TonComment {
+  isEncrypted: boolean;
+  text: string;
+}
+
+export type Transaction = TransactionCommon & {
+  family: FamilyType;
+  fees: BigNumber;
+  comment: TonComment;
+};
+export type TransactionRaw = TransactionCommonRaw & {
+  family: FamilyType;
+  fees: string;
+  comment: TonComment;
+};
+
+export type TransactionStatus = TransactionStatusCommon;
+export type TransactionStatusRaw = TransactionStatusCommonRaw;
+
+export type TonOperation = Operation<TonOperationExtra>;
+
+export type TonPayloadJettonTransfer = {
+  type: "jetton-transfer";
+  queryId: bigint | null;
+  amount: bigint;
+  destination: Address;
+  responseDestination: Address;
+  customPayload: TonCell | null;
+  forwardAmount: bigint;
+  forwardPayload: TonCell | null;
+};
+
+export type TonPayloadNftTransfer = {
+  type: "nft-transfer";
+  queryId: bigint | null;
+  newOwner: Address;
+  responseDestination: Address;
+  customPayload: TonCell | null;
+  forwardAmount: bigint;
+  forwardPayload: TonCell | null;
+};
+
+export type TonPayloadComment = {
+  type: "comment";
+  text: string;
+};
+
+export type TonPayloadFormat = TonPayloadComment | TonPayloadJettonTransfer | TonPayloadNftTransfer;
+
+export interface TonTransaction {
+  to: Address;
+  sendMode: SendMode;
+  seqno: number;
+  timeout: number;
+  bounce: boolean;
+  amount: bigint;
+  stateInit?: StateInit;
+  payload?: TonPayloadFormat;
+}
+
+export interface TonCell extends Cell {}
+
+export type TonOperationExtra = {
+  comment: TonComment;
+  lt: string;
+  explorerHash: string;
+};

package/src/utils.ts

@@ -0,0 +1,120 @@
+import { decodeAccountId } from "@ledgerhq/coin-framework/account/index";
+import { Account } from "@ledgerhq/types-live";
+import { SendMode, Address as TonAddress, WalletContractV4, comment, internal } from "@ton/ton";
+import BigNumber from "bignumber.js";
+import { estimateFee } from "./bridge/bridgeHelpers/api";
+import { TonComment, TonTransaction, Transaction } from "./types";
+
+export const isAddressValid = (recipient: string) => {
+  try {
+    return Boolean(
+      (TonAddress.isRaw(recipient) || TonAddress.isFriendly(recipient)) &&
+        TonAddress.parse(recipient),
+    );
+  } catch {
+    return false;
+  }
+};
+
+export const addressesAreEqual = (addr1: string, addr2: string) => {
+  try {
+    return (
+      isAddressValid(addr1) &&
+      isAddressValid(addr2) &&
+      TonAddress.parse(addr1).equals(TonAddress.parse(addr2))
+    );
+  } catch {
+    return false;
+  }
+};
+
+export const buildTonTransaction = (transaction: Transaction, seqno: number): TonTransaction => {
+  const { useAllAmount, amount, comment, recipient } = transaction;
+  let recipientParsed = recipient;
+  // if recipient is not valid calculate fees with empty address
+  // we handle invalid addresses in account bridge
+  try {
+    TonAddress.parse(recipientParsed);
+  } catch {
+    recipientParsed = new TonAddress(0, Buffer.alloc(32)).toRawString();
+  }
+
+  const finalAmount = useAllAmount ? BigInt(0) : BigInt(amount.toFixed());
+
+  const tonTransaction: TonTransaction = {
+    to: TonAddress.parse(recipientParsed),
+    seqno,
+    amount: finalAmount,
+    bounce: TonAddress.isFriendly(recipientParsed)
+      ? TonAddress.parseFriendly(recipientParsed).isBounceable
+      : true,
+    timeout: getTransferExpirationTime(),
+    sendMode: useAllAmount
+      ? SendMode.CARRY_ALL_REMAINING_BALANCE
+      : SendMode.IGNORE_ERRORS + SendMode.PAY_GAS_SEPARATELY,
+  };
+
+  if (comment.text.length) {
+    tonTransaction.payload = { type: "comment", text: comment.text };
+  }
+
+  return tonTransaction;
+};
+
+// max length is 120 and only ascii allowed
+export const commentIsValid = (msg: TonComment) =>
+  !msg.isEncrypted && msg.text.length <= 120 && /^[\x20-\x7F]*$/.test(msg.text);
+
+// 1 minute
+export const getTransferExpirationTime = () => Math.floor(Date.now() / 1000 + 60);
+
+export const getTonEstimatedFees = async (
+  account: Account,
+  needsInit: boolean,
+  tx: TonTransaction,
+) => {
+  const { xpubOrAddress: pubKey } = decodeAccountId(account.id);
+  if (pubKey.length !== 64) throw Error("[ton] pubKey can't be found");
+  if (tx.payload && tx.payload?.type !== "comment") {
+    throw Error("[ton] payload kind not expected");
+  }
+  const contract = WalletContractV4.create({ workchain: 0, publicKey: Buffer.from(pubKey, "hex") });
+  const transfer = contract.createTransfer({
+    seqno: tx.seqno,
+    secretKey: Buffer.alloc(64), // secretKey set to 0, signature is not verified
+    messages: [
+      internal({
+        bounce: tx.bounce,
+        to: tx.to,
+        value: tx.amount,
+        body: tx.payload?.text ? comment(tx.payload.text) : undefined,
+      }),
+    ],
+    sendMode: tx.sendMode,
+  });
+  const initCode = needsInit ? contract.init.code.toBoc().toString("base64") : undefined;
+  const initData = needsInit ? contract.init.data.toBoc().toString("base64") : undefined;
+  const fee = await estimateFee(
+    account.freshAddress,
+    transfer.toBoc().toString("base64"),
+    initCode,
+    initData,
+  );
+  return BigNumber(fee.fwd_fee + fee.gas_fee + fee.in_fwd_fee + fee.storage_fee);
+};
+
+export const getLedgerTonPath = (path: string): number[] => {
+  const numPath: number[] = [];
+  if (!path) throw Error("[ton] Path is empty");
+  if (path.startsWith("m/")) path = path.slice(2);
+  const pathEntries = path.split("/");
+  if (pathEntries.length !== 6) throw Error(`[ton] Path length is not right ${path}`);
+  for (const entry of pathEntries) {
+    if (!entry.endsWith("'")) throw Error(`[ton] Path entry is not hardened ${path}`);
+    const num = parseInt(entry.slice(0, entry.length - 1));
+    if (!Number.isInteger(num) || num < 0 || num >= 0x80000000)
+      throw Error(`[ton] Path entry is not right ${path}`);
+    numPath.push(num);
+  }
+  return numPath;
+};

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../../tsconfig.base",
+  "compilerOptions": {
+    "declaration": true,
+    "declarationMap": true,
+    "module": "commonjs",
+    "downlevelIteration": true,
+    "lib": ["es2020", "dom"],
+    "outDir": "lib"
+  },
+  "include": ["src/**/*"]
+}