@ledgerhq/coin-ton 0.3.12-next.0

package/src/bridge/bridgeHelpers/txn.ts

@@ -0,0 +1,166 @@
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { Operation } from "@ledgerhq/types-live";
+import { Address } from "@ton/ton";
+import BigNumber from "bignumber.js";
+import { TonOperation } from "../../types";
+import { isAddressValid } from "../../utils";
+import { fetchTransactions } from "./api";
+import { TonAddressBook, TonTransaction, TonTransactionsList } from "./api.types";
+
+export async function getTransactions(
+  addr: string,
+  startLt?: string,
+): Promise<TonTransactionsList> {
+  const txs = await fetchTransactions(addr, { startLt });
+  if (txs.transactions.length === 0) return txs;
+  let tmpTxs: TonTransactionsList;
+  let isUncompletedResult = true;
+
+  while (isUncompletedResult) {
+    const { lt, hash } = txs.transactions[txs.transactions.length - 1];
+    tmpTxs = await fetchTransactions(addr, { startLt, endLt: lt });
+    // we found the last transaction
+    if (tmpTxs.transactions.length === 1) {
+      isUncompletedResult = false;
+      break;
+    }
+    // it should always match
+    if (hash !== tmpTxs.transactions[0].hash) throw Error("[ton] transaction hash does not match");
+    tmpTxs.transactions.shift(); // first element is repeated
+    txs.transactions.push(...tmpTxs.transactions);
+    txs.address_book = { ...txs.address_book, ...tmpTxs.address_book };
+  }
+  return txs;
+}
+
+function getFriendlyAddress(addressBook: TonAddressBook, rawAddr?: string | null): string[] {
+  if (!rawAddr) return [];
+  if (addressBook[rawAddr]) return [addressBook[rawAddr].user_friendly];
+  if (!isAddressValid(rawAddr)) throw new Error("[ton] address is not valid");
+  return [Address.parse(rawAddr).toString({ urlSafe: true, bounceable: true })];
+}
+
+export function mapTxToOps(
+  accountId: string,
+  addr: string,
+  addressBook: TonAddressBook,
+): (tx: TonTransaction) => TonOperation[] {
+  return (tx: TonTransaction): TonOperation[] => {
+    const ops: TonOperation[] = [];
+
+    if (tx.out_msgs.length > 1) throw Error(`[ton] txn with > 1 output not expected ${tx}`);
+
+    const accountAddr = Address.parse(tx.account).toString({ urlSafe: true, bounceable: false });
+
+    if (accountAddr !== addr) throw Error(`[ton] unexpected address ${accountAddr} ${addr}`);
+
+    const isReceiving =
+      tx.in_msg &&
+      tx.in_msg.source &&
+      tx.in_msg.source !== "" &&
+      tx.in_msg.value &&
+      tx.in_msg.value !== "0" &&
+      tx.account === tx.in_msg.destination;
+
+    const isSending =
+      tx.out_msgs.length !== 0 &&
+      tx.out_msgs[0].source &&
+      tx.out_msgs[0].source !== "" &&
+      tx.out_msgs[0].value &&
+      tx.out_msgs[0].value !== "0" &&
+      tx.account === tx.out_msgs[0].source;
+
+    const date = new Date(tx.now * 1000); // now is defined in seconds
+    const hash = tx.in_msg?.hash ?? tx.hash; // this is the hash we know in signature time
+    const hasFailed =
+      tx.description.compute_ph.success === false && tx.description.compute_ph.exit_code !== 0;
+
+    if (isReceiving) {
+      let subOperations: Operation[] | undefined;
+      if (tx.total_fees !== "0") {
+        // these are small amount of fees payed when receiving
+        // we don't want to show them in the charts
+        subOperations = [
+          {
+            id: encodeOperationId(accountId, hash, "NONE"),
+            hash,
+            type: "NONE",
+            value: BigNumber(tx.total_fees),
+            fee: BigNumber(0),
+            blockHeight: tx.mc_block_seqno ?? 1,
+            blockHash: null,
+            hasFailed,
+            accountId,
+            senders: [accountAddr],
+            recipients: [],
+            date,
+            extra: {
+              lt: tx.lt,
+              explorerHash: tx.hash,
+              comment: {
+                isEncrypted: false,
+                text: "",
+              },
+            },
+          },
+        ];
+      }
+      ops.push({
+        id: encodeOperationId(accountId, hash, "IN"),
+        hash,
+        type: "IN",
+        value: BigNumber(tx.in_msg?.value ?? 0),
+        fee: BigNumber(tx.total_fees),
+        blockHeight: tx.mc_block_seqno ?? 1,
+        blockHash: null,
+        hasFailed,
+        accountId,
+        senders: getFriendlyAddress(addressBook, tx.in_msg?.source),
+        recipients: [accountAddr],
+        date,
+        extra: {
+          lt: tx.lt,
+          explorerHash: tx.hash,
+          comment: {
+            isEncrypted: tx.in_msg?.message_content?.decoded?.type === "binary_comment",
+            text:
+              tx.in_msg?.message_content?.decoded?.type === "text_comment"
+                ? tx.in_msg.message_content.decoded.comment
+                : "",
+          },
+        },
+        subOperations,
+      });
+    }
+
+    if (isSending) {
+      ops.push({
+        id: encodeOperationId(accountId, hash, "OUT"),
+        hash: tx.out_msgs[0].hash, // this hash matches with in_msg.hash of IN transaction
+        type: "OUT",
+        value: BigNumber(tx.out_msgs[0].value ?? 0),
+        fee: BigNumber(tx.total_fees),
+        blockHeight: tx.mc_block_seqno ?? 1,
+        blockHash: null,
+        hasFailed,
+        accountId,
+        senders: [accountAddr],
+        recipients: getFriendlyAddress(addressBook, tx.out_msgs[0].destination),
+        date,
+        extra: {
+          lt: tx.lt,
+          explorerHash: tx.hash,
+          comment: {
+            isEncrypted: tx.out_msgs[0].message_content?.decoded?.type === "binary_comment",
+            text:
+              tx.out_msgs[0].message_content?.decoded?.type === "text_comment"
+                ? tx.out_msgs[0].message_content.decoded.comment
+                : "",
+          },
+        },
+      });
+    }
+
+    return ops;
+  };
+}

package/src/bridge/js.ts

@@ -0,0 +1,65 @@
+import getAddressWrapper from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import {
+  defaultUpdateTransaction,
+  makeAccountBridgeReceive,
+  makeScanAccounts,
+} from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+
+import type { AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
+import broadcast from "../broadcast";
+import { TonCoinConfig, setCoinConfig } from "../config";
+import createTransaction from "../createTransaction";
+import estimateMaxSpendable from "../estimateMaxSpendable";
+import getTransactionStatus from "../getTransactionStatus";
+import resolver from "../hw-getAddress";
+import prepareTransaction from "../prepareTransaction";
+import { buildSignOperation } from "../signOperation";
+import { TonSigner } from "../signer";
+import { getAccountShape, sync } from "../synchronisation";
+import type { Transaction } from "../types";
+
+export function buildCurrencyBridge(signerContext: SignerContext<TonSigner>): CurrencyBridge {
+  const getAddress = resolver(signerContext);
+
+  const scanAccounts = makeScanAccounts({
+    getAccountShape,
+    getAddressFn: getAddress,
+  });
+
+  return {
+    preload: async () => Promise.resolve({}),
+    hydrate: () => {},
+    scanAccounts,
+  };
+}
+
+export function buildAccountBridge(
+  signerContext: SignerContext<TonSigner>,
+): AccountBridge<Transaction> {
+  const getAddress = resolver(signerContext);
+
+  const receive = makeAccountBridgeReceive(getAddressWrapper(getAddress));
+  const signOperation = buildSignOperation(signerContext);
+
+  return {
+    estimateMaxSpendable,
+    createTransaction,
+    updateTransaction: defaultUpdateTransaction,
+    getTransactionStatus,
+    prepareTransaction,
+    sync,
+    receive,
+    signOperation,
+    broadcast,
+  };
+}
+
+export function createBridges(signerContext: SignerContext<TonSigner>, coinConfig: TonCoinConfig) {
+  setCoinConfig(coinConfig);
+
+  return {
+    currencyBridge: buildCurrencyBridge(signerContext),
+    accountBridge: buildAccountBridge(signerContext),
+  };
+}

package/src/broadcast.ts

@@ -0,0 +1,13 @@
+import { patchOperationWithHash } from "@ledgerhq/coin-framework/operation";
+import type { AccountBridge } from "@ledgerhq/types-live";
+import { broadcastTx } from "./bridge/bridgeHelpers/api";
+import { Transaction } from "./types";
+
+const broadcast: AccountBridge<Transaction>["broadcast"] = async ({
+  signedOperation: { signature, operation },
+}) => {
+  const hash = await broadcastTx(signature);
+  return patchOperationWithHash(operation, hash);
+};
+
+export default broadcast;

package/src/cli-transaction.ts

@@ -0,0 +1,30 @@
+import invariant from "invariant";
+import flatMap from "lodash/flatMap";
+
+import type { AccountLike } from "@ledgerhq/types-live";
+import { Transaction } from "./types";
+
+function inferTransactions(
+  transactions: Array<{
+    account: AccountLike;
+    transaction: Transaction;
+  }>,
+  opts: Record<string, string>,
+): Transaction[] {
+  return flatMap(transactions, ({ transaction }) => {
+    invariant(transaction.family === "ton", "ton family");
+
+    return {
+      ...transaction,
+      family: "ton",
+      mode: opts.mode || "send",
+    } as Transaction;
+  });
+}
+
+export default function makeCliTools() {
+  return {
+    options: [],
+    inferTransactions,
+  };
+}

package/src/config.ts

@@ -0,0 +1,21 @@
+import { CurrencyConfig } from "@ledgerhq/coin-framework/config";
+
+export type TonCoinConfig = () => CurrencyConfig & {
+  infra: {
+    API_TON_ENDPOINT: string;
+  };
+};
+
+let coinConfig: TonCoinConfig | undefined;
+
+export const setCoinConfig = (config: TonCoinConfig): void => {
+  coinConfig = config;
+};
+
+export const getCoinConfig = (): ReturnType<TonCoinConfig> => {
+  if (!coinConfig?.()) {
+    throw new Error("Ton module config not set");
+  }
+
+  return coinConfig();
+};

package/src/createTransaction.ts

@@ -0,0 +1,17 @@
+import { AccountBridge } from "@ledgerhq/types-live";
+import { BigNumber } from "bignumber.js";
+import type { Transaction } from "./types";
+
+const createTransaction: AccountBridge<Transaction>["createTransaction"] = (): Transaction => ({
+  family: "ton",
+  amount: new BigNumber(0),
+  fees: new BigNumber(0),
+  recipient: "",
+  useAllAmount: false,
+  comment: {
+    isEncrypted: false,
+    text: "",
+  },
+});
+
+export default createTransaction;

package/src/deviceTransactionConfig.ts

@@ -0,0 +1,48 @@
+import { CommonDeviceTransactionField as DeviceTransactionField } from "@ledgerhq/coin-framework/transaction/common";
+import type { Account, AccountLike } from "@ledgerhq/types-live";
+import type { Transaction, TransactionStatus } from "./types";
+
+function getDeviceTransactionConfig(input: {
+  account: AccountLike;
+  parentAccount: Account | null | undefined;
+  transaction: Transaction;
+  status: TransactionStatus;
+}): Array<DeviceTransactionField> {
+  const fields: Array<DeviceTransactionField> = [];
+
+  fields.push({
+    type: "address",
+    label: "To",
+    address: input.transaction.recipient,
+  });
+
+  if (input.transaction.useAllAmount) {
+    fields.push({
+      type: "text",
+      label: "Amount",
+      value: "ALL YOUR TONs",
+    });
+  } else {
+    fields.push({
+      type: "amount",
+      label: "Amount",
+    });
+  }
+
+  fields.push({
+    type: "fees",
+    label: "Fee",
+  });
+
+  if (!input.transaction.comment.isEncrypted && input.transaction.comment.text) {
+    fields.push({
+      type: "text",
+      label: "Comment",
+      value: input.transaction.comment.text,
+    });
+  }
+
+  return fields;
+}
+
+export default getDeviceTransactionConfig;

package/src/errors.ts

@@ -0,0 +1,6 @@
+import { createCustomErrorClass } from "@ledgerhq/errors";
+
+/*
+ * When the comment is invalid.
+ */
+export const TonCommentInvalid = createCustomErrorClass("TonCommentInvalid");

package/src/estimateMaxSpendable.ts

@@ -0,0 +1,40 @@
+import { getMainAccount } from "@ledgerhq/coin-framework/account/index";
+import type { Account, AccountBridge, AccountLike } from "@ledgerhq/types-live";
+import { BigNumber } from "bignumber.js";
+import { fetchAccountInfo } from "./bridge/bridgeHelpers/api";
+import type { Transaction } from "./types";
+import { buildTonTransaction, getTonEstimatedFees } from "./utils";
+
+const estimateMaxSpendable: AccountBridge<Transaction, Account>["estimateMaxSpendable"] = async ({
+  account,
+  parentAccount,
+  transaction,
+}: {
+  account: AccountLike;
+  parentAccount?: Account | null | undefined;
+  transaction?: Transaction | null | undefined;
+}): Promise<BigNumber> => {
+  const mainAccount = getMainAccount(account, parentAccount);
+  let balance = mainAccount.spendableBalance;
+
+  if (balance.eq(0)) return balance;
+
+  const accountInfo = await fetchAccountInfo(mainAccount.freshAddress);
+
+  const estimatedFees = transaction
+    ? transaction.fees ??
+      (await getTonEstimatedFees(
+        mainAccount,
+        accountInfo.status === "uninit",
+        buildTonTransaction(transaction, accountInfo.seqno),
+      ))
+    : BigNumber(0);
+
+  if (balance.lte(estimatedFees)) return new BigNumber(0);
+
+  balance = balance.minus(estimatedFees);
+
+  return balance;
+};
+
+export default estimateMaxSpendable;

package/src/getTransactionStatus.ts

@@ -0,0 +1,130 @@
+import {
+  AmountRequired,
+  InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalance,
+  RecipientRequired,
+} from "@ledgerhq/errors";
+import { Account, AccountBridge, SubAccount } from "@ledgerhq/types-live";
+import BigNumber from "bignumber.js";
+import { TonCommentInvalid } from "./errors";
+import { Transaction, TransactionStatus } from "./types";
+import { addressesAreEqual, commentIsValid, isAddressValid } from "./utils";
+
+type ValidatedTransactionFields = "recipient" | "sender" | "amount" | "transaction";
+type ValidationIssues = Partial<Record<ValidatedTransactionFields, Error>>;
+
+/**
+ * Validate an address for account transaction
+ */
+const validateRecipient = (account: Account, tx: Transaction): Array<ValidationIssues> => {
+  const errors: ValidationIssues = {};
+
+  if (tx.recipient) {
+    // Check if recipient is matching the format of account valid eth address or not
+    const isRecipientValidate = isAddressValid(tx.recipient);
+
+    if (!isRecipientValidate) {
+      errors.recipient = new InvalidAddress("", {
+        currencyName: account.currency.name,
+      });
+    }
+    if (addressesAreEqual(account.freshAddress, tx.recipient)) {
+      errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource("", {
+        currencyName: account.currency.name,
+      });
+    }
+  } else {
+    errors.recipient = new RecipientRequired(); // ""
+  }
+
+  return [errors];
+};
+
+/**
+ * Validate the sender address for account transaction
+ */
+const validateSender = (account: Account): Array<ValidationIssues> => {
+  const errors: ValidationIssues = {};
+
+  // Check if sender is matching the format of account valid ton address or not
+  const isSenderValidate = isAddressValid(account.freshAddress);
+
+  if (!isSenderValidate) {
+    errors.sender = new InvalidAddress("", {
+      currencyName: account.currency.name,
+    });
+  }
+
+  return [errors];
+};
+
+const validateAmount = (
+  account: Account | SubAccount,
+  transaction: Transaction,
+  totalSpent: BigNumber,
+): Array<ValidationIssues> => {
+  const errors: ValidationIssues = {};
+  const warnings: ValidationIssues = {};
+
+  // if no amount or 0
+  if (!transaction.amount || transaction.amount.isZero()) {
+    errors.amount = new AmountRequired(); // "Amount required"
+  } else if (totalSpent.isGreaterThan(account.balance)) {
+    // if not enough to make the transaction
+    errors.amount = new NotEnoughBalance(); // "Sorry, insufficient funds"
+  }
+
+  return [errors, warnings];
+};
+
+const validateComment = (transaction: Transaction): Array<ValidationIssues> => {
+  const errors: ValidationIssues = {};
+
+  // if the comment isn'transaction encrypted, it should be valid
+  if (transaction.comment.isEncrypted || !commentIsValid(transaction.comment)) {
+    errors.transaction = new TonCommentInvalid();
+  }
+  return [errors];
+};
+
+export const getTransactionStatus: AccountBridge<
+  Transaction,
+  Account,
+  TransactionStatus
+>["getTransactionStatus"] = async (
+  account: Account,
+  transaction: Transaction,
+): Promise<TransactionStatus> => {
+  const totalSpent = transaction.amount.plus(transaction.fees);
+
+  // Recipient related errors and warnings
+  const [recipientErr] = validateRecipient(account, transaction);
+  // Sender related errors and warnings
+  const [senderErr] = validateSender(account);
+  // Amount related errors and warnings
+  const [amountErr, amountWarn] = validateAmount(account, transaction, totalSpent);
+  // Transaction related errors and warnings
+  const [transactionErr] = validateComment(transaction);
+
+  const errors: ValidationIssues = {
+    ...recipientErr,
+    ...senderErr,
+    ...amountErr,
+    ...transactionErr,
+  };
+
+  const warnings: ValidationIssues = {
+    ...amountWarn,
+  };
+
+  return {
+    amount: transaction.amount,
+    errors,
+    warnings,
+    estimatedFees: transaction.fees,
+    totalSpent,
+  };
+};
+
+export default getTransactionStatus;

package/src/hw-getAddress.ts

@@ -0,0 +1,28 @@
+import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import { GetAddressOptions } from "@ledgerhq/coin-framework/derivation";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { TonSigner } from "./signer";
+import { getLedgerTonPath } from "./utils";
+
+const resolver = (signerContext: SignerContext<TonSigner>): GetAddressFn => {
+  return async (deviceId: string, { path, verify }: GetAddressOptions) => {
+    const ledgerPath = getLedgerTonPath(path);
+
+    const sig = await signerContext(deviceId, async signer => {
+      return verify
+        ? await signer.validateAddress(ledgerPath, { bounceable: false })
+        : await signer.getAddress(ledgerPath, { bounceable: false });
+    });
+
+    if (!sig.address || !sig.publicKey.length)
+      throw Error(`[ton] Response is empty ${sig.address} ${sig.publicKey}`);
+
+    return {
+      address: sig.address,
+      publicKey: sig.publicKey.toString("hex"),
+      path,
+    };
+  };
+};
+
+export default resolver;

package/src/hw-signMessage.ts

@@ -0,0 +1,31 @@
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { Account, AnyMessage } from "@ledgerhq/types-live";
+import { TonSigner } from "./signer";
+import { TonTransaction } from "./types";
+import { getLedgerTonPath } from "./utils";
+
+export const signMessage =
+  (signerContext: SignerContext<TonSigner>) =>
+  async (deviceId: string, account: Account, { message }: AnyMessage) => {
+    if (typeof message !== "string") throw new Error("Invalid message value");
+
+    const parsedMessage = JSON.parse(message);
+    const ledgerPath = getLedgerTonPath(account.freshAddressPath);
+
+    const sig = await signerContext(deviceId, signer =>
+      signer.signTransaction(ledgerPath, parsedMessage as TonTransaction),
+    );
+
+    if (!sig) {
+      throw new Error("No signature");
+    }
+
+    return {
+      rsv: {
+        r: "",
+        s: "",
+        v: 0,
+      },
+      signature: sig.toString(),
+    };
+  };

package/src/prepareTransaction.ts

@@ -0,0 +1,27 @@
+import { defaultUpdateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { Account, AccountBridge } from "@ledgerhq/types-live";
+import { fetchAccountInfo } from "./bridge/bridgeHelpers/api";
+import type { Transaction } from "./types";
+import { buildTonTransaction, getTonEstimatedFees } from "./utils";
+
+const prepareTransaction: AccountBridge<Transaction, Account>["prepareTransaction"] = async (
+  account: Account,
+  transaction: Transaction,
+): Promise<Transaction> => {
+  const accountInfo = await fetchAccountInfo(account.freshAddress);
+
+  const simpleTx = buildTonTransaction(transaction, accountInfo.seqno);
+
+  const fees = await getTonEstimatedFees(account, accountInfo.status === "uninit", simpleTx);
+
+  let amount;
+  if (transaction.useAllAmount) {
+    amount = account.spendableBalance.minus(fees);
+  } else {
+    amount = transaction.amount;
+  }
+
+  return defaultUpdateTransaction(transaction, { fees, amount });
+};
+
+export default prepareTransaction;