@ledgerhq/coin-canton 0.2.0-nightly.0

package/src/bridge/getTransactionStatus.ts

@@ -0,0 +1,88 @@
+import {
+  AmountRequired,
+  FeeNotLoaded,
+  FeeRequired,
+  FeeTooHigh,
+  InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalanceBecauseDestinationNotCreated,
+  NotEnoughSpendableBalance,
+  RecipientRequired,
+} from "@ledgerhq/errors";
+import BigNumber from "bignumber.js";
+import { Account, AccountBridge } from "@ledgerhq/types-live";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+import { Transaction, TransactionStatus } from "../types";
+import { isRecipientValid } from "../common-logic/utils";
+import coinConfig from "../config";
+
+export const getTransactionStatus: AccountBridge<
+  Transaction,
+  Account,
+  TransactionStatus
+>["getTransactionStatus"] = async (account, transaction) => {
+  const errors: Record<string, Error> = {};
+  const warnings: Record<string, Error> = {};
+
+  // reserveAmount is the minimum amount of currency that an account must hold in order to stay activated
+  const reserveAmount = new BigNumber(coinConfig.getCoinConfig().minReserve);
+  const estimatedFees = new BigNumber(transaction.fee || 0);
+  const totalSpent = new BigNumber(transaction.amount).plus(estimatedFees);
+  const amount = new BigNumber(transaction.amount);
+
+  if (amount.gt(0) && estimatedFees.times(10).gt(amount)) {
+    // if the fee is more than 10 times the amount, we warn the user that fee is high compared to what he is sending
+    warnings.feeTooHigh = new FeeTooHigh();
+  }
+
+  if (!transaction.fee) {
+    // if the fee is not loaded, we can't do much
+    errors.fee = new FeeNotLoaded();
+  } else if (transaction.fee.eq(0)) {
+    // On some chains, 0 fee could still work so this is optional
+    errors.fee = new FeeRequired();
+  } else if (totalSpent.gt(account.balance.minus(reserveAmount))) {
+    // if the total spent is greater than the balance minus the reserve amount, tx is invalid
+    errors.amount = new NotEnoughSpendableBalance("", {
+      minimumAmount: formatCurrencyUnit(account.currency.units[0], reserveAmount, {
+        disableRounding: true,
+        useGrouping: false,
+        showCode: true,
+      }),
+    });
+  } else if (transaction.recipient && transaction.amount.lt(reserveAmount)) {
+    // if we send an amount lower than reserve amount AND target account is new, we need to warn the user that the target account will not be activated
+    errors.amount = new NotEnoughBalanceBecauseDestinationNotCreated("", {
+      minimalAmount: formatCurrencyUnit(account.currency.units[0], reserveAmount, {
+        disableRounding: true,
+        useGrouping: false,
+        showCode: true,
+      }),
+    });
+  }
+
+  if (!transaction.recipient) {
+    errors.recipient = new RecipientRequired("");
+  } else if (account.freshAddress === transaction.recipient) {
+    // we want to prevent user from sending to themselves (even if it's technically feasible)
+    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+  } else if (!isRecipientValid(transaction.recipient)) {
+    // We want to prevent user from sending to an invalid address
+    errors.recipient = new InvalidAddress("", {
+      currencyName: account.currency.name,
+    });
+  }
+
+  if (!errors.amount && amount.eq(0)) {
+    // if the amount is 0, we prevent the user from sending the tx (even if it's technically feasible)
+    errors.amount = new AmountRequired();
+  }
+
+  return {
+    errors,
+    warnings,
+    estimatedFees,
+    amount,
+    totalSpent,
+  };
+};

package/src/bridge/index.test.ts

@@ -0,0 +1,31 @@
+import { createBridges } from ".";
+
+describe("createBridges", () => {
+  it("should return both bridges interface", () => {
+    const bridges = createBridges(undefined as any, {} as any);
+    expect(bridges.accountBridge).toBeDefined();
+    expect(bridges.currencyBridge).toBeDefined();
+  });
+
+  it("should have a currency bridge with required methods", () => {
+    const bridges = createBridges(undefined as any, {} as any);
+    expect(bridges.currencyBridge).toBeDefined();
+    expect(bridges.currencyBridge.preload).toBeDefined();
+    expect(bridges.currencyBridge.hydrate).toBeDefined();
+    expect(bridges.currencyBridge.scanAccounts).toBeDefined();
+  });
+
+  it("should have an account bridge with required methods", () => {
+    const bridges = createBridges(undefined as any, {} as any);
+    expect(bridges.accountBridge).toBeDefined();
+    expect(bridges.accountBridge.broadcast).toBeDefined();
+    expect(bridges.accountBridge.createTransaction).toBeDefined();
+    expect(bridges.accountBridge.estimateMaxSpendable).toBeDefined();
+    expect(bridges.accountBridge.getTransactionStatus).toBeDefined();
+    expect(bridges.accountBridge.prepareTransaction).toBeDefined();
+    expect(bridges.accountBridge.receive).toBeDefined();
+    expect(bridges.accountBridge.signOperation).toBeDefined();
+    expect(bridges.accountBridge.sync).toBeDefined();
+    expect(bridges.accountBridge.updateTransaction).toBeDefined();
+  });
+});

package/src/bridge/index.ts

@@ -0,0 +1,62 @@
+import getAddressWrapper from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import {
+  getSerializedAddressParameters,
+  makeAccountBridgeReceive,
+  makeScanAccounts,
+  makeSync,
+} from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { CoinConfig } from "@ledgerhq/coin-framework/config";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import type { AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
+import cantonCoinConfig, { type CantonCoinConfig } from "../config";
+import resolver from "../signer";
+import { BoilerplateSigner } from "../types";
+import type { Transaction } from "../types";
+import { broadcast } from "./broadcast";
+import { createTransaction } from "./createTransaction";
+import { estimateMaxSpendable } from "./estimateMaxSpendable";
+import { getTransactionStatus } from "./getTransactionStatus";
+import { prepareTransaction } from "./prepareTransaction";
+import { buildSignOperation } from "./signOperation";
+import { getAccountShape } from "./sync";
+import { updateTransaction } from "./updateTransaction";
+
+export function createBridges(
+  signerContext: SignerContext<BoilerplateSigner>,
+  coinConfig: CoinConfig<CantonCoinConfig>,
+) {
+  cantonCoinConfig.setCoinConfig(coinConfig);
+
+  const getAddress = resolver(signerContext);
+  const receive = makeAccountBridgeReceive(getAddressWrapper(getAddress));
+
+  const scanAccounts = makeScanAccounts({ getAccountShape, getAddressFn: getAddress });
+  const currencyBridge: CurrencyBridge = {
+    preload: () => Promise.resolve({}),
+    hydrate: () => {},
+    scanAccounts,
+  };
+
+  const signOperation = buildSignOperation(signerContext);
+  const sync = makeSync({ getAccountShape });
+  // we want one method per file
+  const accountBridge: AccountBridge<Transaction> = {
+    broadcast,
+    createTransaction,
+    updateTransaction,
+    // NOTE: use updateTransaction: defaultUpdateTransaction<Transaction>,
+    // if you don't need to update the transaction patch object
+    prepareTransaction,
+    getTransactionStatus,
+    estimateMaxSpendable,
+    sync,
+    receive,
+    signOperation,
+    getSerializedAddressParameters,
+  };
+
+  return {
+    currencyBridge,
+    accountBridge,
+  };
+}

package/src/bridge/prepareTransaction.test.ts

@@ -0,0 +1,29 @@
+import BigNumber from "bignumber.js";
+import { craftTransaction, estimateFees } from "../common-logic";
+import { getNextSequence } from "../network/node";
+import { prepareTransaction } from "./prepareTransaction";
+import { Account } from "@ledgerhq/types-live";
+import { Transaction } from "../types";
+
+jest.mock("../network/node");
+jest.mock("../common-logic");
+
+describe("prepareTransaction", () => {
+  let estimateFeesSpy: jest.SpyInstance;
+  let getNextSequenceSpy: jest.SpyInstance;
+  let craftTransactionSpy: jest.SpyInstance;
+  beforeEach(() => {
+    getNextSequenceSpy = jest.spyOn({ getNextSequence }, "getNextSequence");
+    estimateFeesSpy = jest.spyOn({ estimateFees }, "estimateFees");
+    craftTransactionSpy = jest.spyOn({ craftTransaction }, "craftTransaction");
+    craftTransactionSpy.mockReturnValue({ serializedTransaction: "serialized" });
+  });
+
+  it("should update fee field if it's different", async () => {
+    getNextSequenceSpy.mockResolvedValue(42);
+    const oldTx = { fee: new BigNumber(0) };
+    estimateFeesSpy.mockResolvedValue(BigInt(1));
+    const newTx = await prepareTransaction({} as Account, oldTx as Transaction);
+    expect(newTx.fee).toEqual(new BigNumber(1));
+  });
+});

package/src/bridge/prepareTransaction.ts

@@ -0,0 +1,25 @@
+import { AccountBridge } from "@ledgerhq/types-live";
+import { Transaction } from "../types";
+import { craftTransaction, estimateFees } from "../common-logic";
+import { getNextSequence } from "../network/node";
+import BigNumber from "bignumber.js";
+
+export const prepareTransaction: AccountBridge<Transaction>["prepareTransaction"] = async (
+  account,
+  transaction,
+) => {
+  const seq = await getNextSequence(account.freshAddress);
+
+  const craftedTransaction = await craftTransaction(
+    { address: account.freshAddress, nextSequenceNumber: seq },
+    { amount: transaction.amount, recipient: transaction.recipient },
+  );
+
+  const fee = await estimateFees(craftedTransaction.serializedTransaction);
+
+  if (transaction.fee !== new BigNumber(fee.toString())) {
+    return { ...transaction, fee: new BigNumber(fee.toString()) };
+  }
+
+  return transaction;
+};

package/src/bridge/signOperation.ts

@@ -0,0 +1,93 @@
+import { Observable } from "rxjs";
+import { FeeNotLoaded } from "@ledgerhq/errors";
+import { AccountBridge, Operation } from "@ledgerhq/types-live";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { combine, craftTransaction, getNextValidSequence } from "../common-logic";
+import { Transaction, BoilerplateSigner, BoilerplateNativeTransaction } from "../types";
+
+export const buildSignOperation =
+  (signerContext: SignerContext<BoilerplateSigner>): AccountBridge<Transaction>["signOperation"] =>
+  ({ account, deviceId, transaction }) =>
+    new Observable(o => {
+      async function main() {
+        const { fee } = transaction;
+        if (!fee) throw new FeeNotLoaded();
+
+        try {
+          // o observables allows to define steps of the signing process with the device
+          o.next({
+            type: "device-signature-requested",
+          });
+
+          const nextSequenceNumber = await getNextValidSequence(account.freshAddress);
+
+          const signature = await signerContext(deviceId, async signer => {
+            const { freshAddressPath: derivationPath } = account;
+            const { publicKey } = await signer.getAddress(derivationPath);
+
+            const { nativeTransaction, serializedTransaction } = await craftTransaction(
+              {
+                address: account.freshAddress,
+                publicKey,
+              },
+              {
+                recipient: transaction.recipient,
+                amount: transaction.amount,
+                fee: fee,
+              },
+            );
+
+            const transactionSignature = await signer.signTransaction(
+              derivationPath,
+              serializedTransaction,
+            );
+
+            return combine(serializedTransaction, transactionSignature, publicKey);
+          });
+
+          o.next({
+            type: "device-signature-granted",
+          });
+
+          // We create an optimistic operation here, the framework will then replace this transaction with the one returned by the indexer
+          const hash = "";
+          const operation: Operation = {
+            id: encodeOperationId(account.id, hash, "OUT"),
+            hash,
+            accountId: account.id,
+            type: "OUT",
+            value: transaction.amount,
+            fee,
+            blockHash: null,
+            blockHeight: null,
+            senders: [account.freshAddress],
+            recipients: [transaction.recipient],
+            date: new Date(),
+            transactionSequenceNumber: nextSequenceNumber,
+            extra: {},
+          };
+
+          o.next({
+            type: "signed",
+            signedOperation: {
+              operation,
+              signature,
+            },
+          });
+        } catch (e) {
+          if (e instanceof Error) {
+            throw new Error(
+              (e as Error & { data?: { resultMessage?: string } })?.data?.resultMessage,
+            );
+          }
+
+          throw e;
+        }
+      }
+
+      main().then(
+        () => o.complete(),
+        e => o.error(e),
+      );
+    });

package/src/bridge/sync.ts

@@ -0,0 +1,106 @@
+import BigNumber from "bignumber.js";
+import { Operation } from "@ledgerhq/types-live";
+import { encodeAccountId } from "@ledgerhq/coin-framework/account/index";
+import { GetAccountShape, mergeOps } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { getTransactions } from "../network/indexer";
+import { getAccountInfo, getBlockHeight } from "../network/node";
+
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { BoilerplateOperation } from "../network/types";
+import coinConfig from "../config";
+
+const operationAdapter =
+  (accountId: string, address: string) =>
+  ({
+    meta: { delivered_amount },
+    tx: { Fee, hash, inLedger, date, Account, Destination, Sequence },
+  }: BoilerplateOperation) => {
+    const type = Account === address ? "OUT" : "IN";
+    let value =
+      delivered_amount && typeof delivered_amount === "string"
+        ? new BigNumber(delivered_amount)
+        : new BigNumber(0);
+    const feeValue = new BigNumber(Fee);
+
+    if (type === "OUT") {
+      if (!Number.isNaN(feeValue)) {
+        value = value.plus(feeValue);
+      }
+    }
+
+    const op: Operation = {
+      id: encodeOperationId(accountId, hash, type),
+      hash: hash,
+      accountId,
+      type,
+      value,
+      fee: feeValue,
+      blockHash: null,
+      blockHeight: inLedger,
+      senders: [Account],
+      recipients: [Destination],
+      date: new Date(),
+      transactionSequenceNumber: Sequence,
+      extra: {},
+    };
+
+    return op;
+  };
+
+const filterOperations = (
+  transactions: BoilerplateOperation[],
+  accountId: string,
+  address: string,
+) => {
+  return transactions
+    .filter(
+      ({ tx, meta }: BoilerplateOperation) =>
+        tx.TransactionType === "Payment" && typeof meta.delivered_amount === "string",
+    )
+    .map(operationAdapter(accountId, address))
+    .filter((op): op is Operation => Boolean(op));
+};
+
+export const getAccountShape: GetAccountShape = async info => {
+  const { address, initialAccount, currency, derivationMode } = info;
+
+  const accountId = encodeAccountId({
+    type: "js",
+    version: "2",
+    currencyId: currency.id,
+    xpubOrAddress: address,
+    derivationMode,
+  });
+
+  // blockheight retrieval
+  const blockHeight = await getBlockHeight();
+
+  // Account info retrieval + spendable balance calculation
+  const accountInfo = await getAccountInfo(address);
+  const balance = new BigNumber(accountInfo.account_data.Balance);
+  const reserveMin = coinConfig.getCoinConfig().minReserve;
+  const spendableBalance = new BigNumber(accountInfo.account_data.Balance).minus(reserveMin);
+
+  // Tx history fetching
+  const oldOperations = initialAccount?.operations || [];
+  const startAt = oldOperations.length ? (oldOperations[0].blockHeight || 0) + 1 : 0;
+  const newTransactions = await getTransactions(address, {
+    from: startAt,
+    size: 100,
+  });
+  const newOperations = filterOperations(newTransactions, accountId, address);
+  const operations = mergeOps(oldOperations, newOperations as Operation[]);
+
+  // We return the new account shape
+  const shape = {
+    id: accountId,
+    xpub: address,
+    blockHeight,
+    balance,
+    spendableBalance,
+    operations,
+    operationsCount: operations.length,
+  };
+
+  return shape;
+};

package/src/bridge/transaction.ts

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

package/src/bridge/updateTransaction.ts

@@ -0,0 +1,17 @@
+import { updateTransaction as defaultUpdateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import { AccountBridge } from "@ledgerhq/types-live";
+import type { Transaction } from "../types";
+
+// NOTE: this method is optional, use defaultUpdateTransaction
+// acts as a middleware to update the transaction patch object
+
+// NOTE: here is an example transaction updater function
+// in this case, it resets fee to null depending on the patch content
+export const updateTransaction: AccountBridge<Transaction>["updateTransaction"] = (tx, patch) => {
+  // eslint-disable-next-line no-constant-condition
+  if (patch.recipient === "boilerplate1" || true) {
+    patch = { ...patch, fee: null };
+  }
+
+  return defaultUpdateTransaction(tx, patch);
+};

package/src/common-logic/account/getBalance.ts

@@ -0,0 +1,8 @@
+import { Balance } from "@ledgerhq/coin-framework/api/types";
+import { getAccountInfo } from "../../network/node";
+
+// Could be getAccountInfo so it is used in both bridge and api
+export async function getBalance(address: string): Promise<Balance[]> {
+  const accountInfo = await getAccountInfo(address);
+  return [{ asset: { type: "native" }, value: BigInt(accountInfo.account_data.Balance) }];
+}

package/src/common-logic/account/getNextSequence.ts

@@ -0,0 +1,6 @@
+import { getNextSequence } from "../../network/node";
+
+// Could be getAccountInfo so it is used in both bridge and api
+export async function getNextValidSequence(address: string): Promise<number> {
+  return await getNextSequence(address);
+}

package/src/common-logic/common.ts

@@ -0,0 +1,9 @@
+import { BigNumber } from "bignumber.js";
+import { parseCurrencyUnit } from "@ledgerhq/coin-framework/currencies";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+
+// NOTE: replace ripple by your currency id, it should be found in
+// libs/ledgerjs/packages/cryptoassets/src/currencies.ts
+const boilerplateUnit = getCryptoCurrencyById("ripple").units[0];
+export const parseAPIValue = (value: string): BigNumber =>
+  parseCurrencyUnit(boilerplateUnit, value);

package/src/common-logic/history/lastBlock.ts

@@ -0,0 +1,11 @@
+import type { BlockInfo } from "@ledgerhq/coin-framework/api/index";
+import { getLastBlock } from "../../network/node";
+
+export async function lastBlock(): Promise<BlockInfo> {
+  const result = await getLastBlock();
+  return {
+    height: result.blockHeight,
+    hash: result.blockHash,
+    time: new Date(result.timestamp),
+  };
+}

package/src/common-logic/history/listOperations.ts

@@ -0,0 +1,64 @@
+import type { Operation, Pagination } from "@ledgerhq/coin-framework/api/index";
+import { getTransactions } from "../../network/indexer";
+import { BoilerplateOperation } from "../../network/types";
+
+/**
+ * Returns list of operations associated to an account.
+ * @param address Account address
+ * @param pagination Pagination options
+ * @returns Operations found and the next "id" or "index" to use for pagination (i.e. `start` property).\
+ * If `0` is returns, no pagination needed.
+ * This "id" or "index" value, thus it has functional meaning, is different for each blockchain.
+ */
+export async function listOperations(
+  address: string,
+  page: Pagination,
+): Promise<[Operation[], string]> {
+  const transactions = await getTransactions(address, { from: page.minHeight });
+  return [transactions.map(convertToCoreOperation(address)), ""];
+}
+
+const convertToCoreOperation =
+  (address: string) =>
+  (operation: BoilerplateOperation): Operation => {
+    const {
+      meta: { delivered_amount },
+      tx: { Fee, hash, inLedger, date, Account, Destination },
+    } = operation;
+
+    const type = Account === address ? "OUT" : "IN";
+    let value =
+      delivered_amount && typeof delivered_amount === "string"
+        ? BigInt(delivered_amount)
+        : BigInt(0);
+
+    const feeValue = BigInt(Fee);
+    if (type === "OUT") {
+      if (!Number.isNaN(feeValue)) {
+        value = value + feeValue;
+      }
+    }
+
+    return {
+      /**
+       * Note: The operation ID must be concatenated with another
+       * value if the transaction hash is not enough to identify it
+       */
+      id: hash,
+      asset: { type: "native" },
+      tx: {
+        hash,
+        fees: feeValue,
+        date: new Date(date),
+        block: {
+          height: inLedger,
+          hash,
+          time: new Date(date),
+        },
+      },
+      type,
+      value,
+      senders: [Account],
+      recipients: [Destination],
+    };
+  };

package/src/common-logic/index.ts

@@ -0,0 +1,11 @@
+export { broadcast } from "./transaction/broadcast";
+export { combine } from "./transaction/combine";
+export { craftTransaction } from "./transaction/craftTransaction";
+export { estimateFees } from "./transaction/estimateFees";
+export { getBalance } from "./account/getBalance";
+export { lastBlock } from "./history/lastBlock";
+export { listOperations } from "./history/listOperations";
+export { isRecipientValid } from "./utils";
+export { getNextValidSequence } from "./account/getNextSequence";
+
+export { parseAPIValue } from "./common";

package/src/common-logic/transaction/broadcast.ts

@@ -0,0 +1,6 @@
+import { submit } from "../../network/node";
+
+export async function broadcast(signedTx: string): Promise<string> {
+  const submittedPayment = await submit(signedTx);
+  return submittedPayment.tx_hash;
+}

package/src/common-logic/transaction/combine.ts

@@ -0,0 +1,6 @@
+import { encode } from "../utils";
+
+// Combines signature with raw transaction
+export function combine(transaction: string, signature: string, publicKey?: string): string {
+  return encode(transaction, signature, publicKey || "");
+}