@ledgerhq/coin-canton 0.2.0-nightly.0

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

@@ -0,0 +1,36 @@
+import BigNumber from "bignumber.js";
+import { BoilerplateNativeTransaction } from "../../types";
+
+const encodeNativeTx = (nativeTx: BoilerplateNativeTransaction) => JSON.stringify(nativeTx);
+
+export async function craftTransaction(
+  account: {
+    address: string;
+    nextSequenceNumber?: number;
+    publicKey?: string;
+  },
+  transaction: {
+    recipient?: string;
+    amount: BigNumber;
+    fee?: BigNumber;
+  },
+): Promise<{
+  nativeTransaction: BoilerplateNativeTransaction;
+  serializedTransaction: string;
+}> {
+  const nativeTransaction: BoilerplateNativeTransaction = {
+    TransactionType: "Payment",
+    Account: account.address,
+    Amount: transaction.amount.toString(),
+    Destination: transaction.recipient || "",
+    Fee: transaction.fee?.toString() || "0",
+    Sequence: account.nextSequenceNumber || 0,
+  };
+
+  const serializedTransaction = encodeNativeTx(nativeTransaction);
+
+  return {
+    nativeTransaction,
+    serializedTransaction,
+  };
+}

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

@@ -0,0 +1,16 @@
+import { simulate } from "../../network/node";
+import { SimulationError } from "../../types/errors";
+
+export async function estimateFees(serializedTransaction: string): Promise<bigint> {
+  try {
+    // We call the node to do a dry run and estimate fees
+    return BigInt(await simulate(serializedTransaction));
+  } catch (e) {
+    // default value is required in case of simulation error, else user will encounter an error in the flow
+    if (e instanceof SimulationError) {
+      return BigInt(1000);
+    } else {
+      throw new Error("Unexpected error while estimating fees.");
+    }
+  }
+}

package/src/common-logic/utils.ts

@@ -0,0 +1,18 @@
+import BigNumber from "bignumber.js";
+
+export const UINT32_MAX = new BigNumber(2).pow(32).minus(1);
+
+export const validateTag = (tag: BigNumber) => {
+  return (
+    !tag.isNaN() && tag.isFinite() && tag.isInteger() && tag.isPositive() && tag.lte(UINT32_MAX)
+  );
+};
+
+export function isRecipientValid(recipient: string): boolean {
+  return recipient.length > 0;
+}
+
+export const encode = (transaction: string, signature: string, publicKey?: string) => {
+  // sample encoding
+  return `${transaction}${publicKey}${signature}encodedTx`;
+};

package/src/config.ts

@@ -0,0 +1,12 @@
+import buildCoinConfig, { type CurrencyConfig } from "@ledgerhq/coin-framework/config";
+
+export type CantonConfig = {
+  nodeUrl: string;
+  minReserve: number;
+};
+
+export type CantonCoinConfig = CurrencyConfig & CantonConfig;
+
+const coinConfig = buildCoinConfig<CantonCoinConfig>();
+
+export default coinConfig;

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from "./types";
+
+export { createBridges } from "./bridge/index";
+export type { CantonCoinConfig } from "./config";

package/src/network/indexer.ts

@@ -0,0 +1,17 @@
+import { AccountTxResponse } from "./types";
+import network from "@ledgerhq/live-network/network";
+import { getEnv } from "@ledgerhq/live-env";
+
+export const getTransactions = async (
+  address: string,
+  params: { from: number; size?: number },
+): Promise<AccountTxResponse["transactions"]> => {
+  const { data } = await network<AccountTxResponse>({
+    // NOTE: add INDEXER_BOILERPLATE to libs/env/src/env.ts
+    // @ts-expect-error: add INDEXER_BOILERPLATE to libs/env/src/env.ts
+    url: `${getEnv("INDEXER_BOILERPLATE")}/account/${address}/transactions`,
+    method: "GET",
+  });
+
+  return data.transactions;
+};

package/src/network/mock-network.ts

@@ -0,0 +1,25 @@
+/*
+
+In a real use case you should use live-network library like this :
+
+import network from "@ledgerhq/live-network/network";
+
+
+instead of this mocked method
+
+*/
+
+export const network = (params: { url: string; method: "GET" | "POST" }) => {
+  switch (true) {
+    case params.url.includes("simulate"):
+      break;
+    case params.url.includes("submit"):
+      break;
+    case params.url.includes("account_info"):
+      break;
+    case params.url.includes("transactions"):
+      break;
+    default:
+      throw new Error("Mock network 404");
+  }
+};

package/src/network/node.ts

@@ -0,0 +1,94 @@
+import { SimulationError } from "../types/errors";
+import network from "@ledgerhq/live-network/network";
+import { getEnv } from "@ledgerhq/live-env";
+import coinConfig from "../config";
+import { AccountInfoResponse, SubmitReponse } from "./types";
+
+const getNodeUrl = () => coinConfig.getCoinConfig().nodeUrl;
+
+// NOTE: add NODE_BOILERPLATE to libs/env/src/env.ts
+
+// txPayload needs to be unsigned
+export const simulate = async (serializedTx: string): Promise<number> => {
+  // @ts-expect-error: add NODE_BOILERPLATE to libs/env/src/env.ts
+  const url = `${getEnv("NODE_BOILERPLATE")}/simulate`;
+  const { data } = await network({
+    url,
+    method: "POST",
+    data: {
+      txPayload: serializedTx,
+    },
+  });
+  if (data.error) {
+    throw new SimulationError();
+  }
+  return data.fees;
+};
+
+// can be called nonce or sequence
+export const getNextSequence = async (address: string): Promise<number> => {
+  // @ts-expect-error: add NODE_BOILERPLATE to libs/env/src/env.ts
+  const url = `${getEnv("NODE_BOILERPLATE")}/${address}/sequence`;
+  try {
+    const { data } = await network({
+      url,
+      method: "GET",
+    });
+    return data.sequence;
+  } catch (e) {
+    return 0;
+  }
+};
+
+export const getBlockHeight = async (): Promise<number> => {
+  // @ts-expect-error: add NODE_BOILERPLATE to libs/env/src/env.ts
+  const url = `${getEnv("NODE_BOILERPLATE")}/blockheight`;
+  const { data } = await network({
+    url,
+    method: "GET",
+  });
+  return data.blockHeight;
+};
+
+export const getLastBlock = async (): Promise<{
+  blockHeight: number;
+  blockHash: string;
+  timestamp: number;
+}> => {
+  // @ts-expect-error: add NODE_BOILERPLATE to libs/env/src/env.ts
+  const url = `${getEnv("NODE_BOILERPLATE")}/block/current`;
+  const { data } = await network({
+    url,
+    method: "GET",
+  });
+  return data;
+};
+
+export const submit = async (signedTx: string): Promise<SubmitReponse> => {
+  // @ts-expect-error: add NODE_BOILERPLATE to libs/env/src/env.ts
+  const url = `${getEnv("NODE_BOILERPLATE")}/submit`;
+  const { data } = await network<SubmitReponse>({
+    url,
+    method: "GET",
+  });
+  return data;
+};
+
+export const getAccountInfo = async (address: string): Promise<AccountInfoResponse> => {
+  const {
+    data: { result },
+  } = await network<{ result: AccountInfoResponse }>({
+    method: "POST",
+    url: getNodeUrl(),
+    data: {
+      method: "account_info",
+      params: [
+        {
+          account: address,
+        },
+      ],
+    },
+  });
+
+  return result;
+};

package/src/network/types.ts

@@ -0,0 +1,51 @@
+export type BoilerplateOperation = {
+  meta: {
+    delivered_amount: string;
+  };
+  tx: {
+    Account: string;
+    Amount: string;
+    Destination: string;
+    Fee: string;
+    Memo: string;
+    Sequence: number;
+    SigningPubKey: string;
+    TransactionType: string;
+    TxnSignature: string;
+    date: number;
+    hash: string;
+    inLedger: number;
+  };
+  validated: boolean;
+};
+
+export type ResponseStatus =
+  | { status: string; error?: never }
+  | {
+      status?: never;
+      error: string;
+    };
+export function isResponseStatus(obj: object): obj is ResponseStatus {
+  return "status" in obj || "error" in obj;
+}
+
+export type NewAccount = "NewAccount";
+export type AccountInfoResponse = {
+  account_data: {
+    Account: string;
+    Balance: string;
+  };
+  ledger_hash: string;
+  ledger_index: number;
+  validated: boolean;
+} & ResponseStatus;
+
+export type SubmitReponse = {
+  accepted: boolean;
+  tx_hash: string;
+};
+
+export type AccountTxResponse = {
+  account: string;
+  transactions: BoilerplateOperation[];
+} & ResponseStatus;

package/src/signer/getAddress.ts

@@ -0,0 +1,20 @@
+import { GetAddressOptions } from "@ledgerhq/coin-framework/derivation";
+import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { BoilerplateAddress, BoilerplateSigner } from "../types";
+
+const getAddress = (signerContext: SignerContext<BoilerplateSigner>): GetAddressFn => {
+  return async (deviceId: string, { path, verify }: GetAddressOptions) => {
+    const { address, publicKey } = (await signerContext(deviceId, signer =>
+      signer.getAddress(path),
+    )) as BoilerplateAddress;
+
+    return {
+      path,
+      address,
+      publicKey,
+    };
+  };
+};
+
+export default getAddress;

package/src/signer/index.ts

@@ -0,0 +1,7 @@
+/**
+ * This directory is the home for all types and logic based on Ledgers signer.
+ */
+
+import getAddress from "./getAddress";
+
+export default getAddress;

package/src/test/bot-deviceActions.ts

@@ -0,0 +1,48 @@
+import type { DeviceAction } from "@ledgerhq/coin-framework/bot/types";
+import type { Transaction } from "../types";
+import {
+  deviceActionFlow,
+  formatDeviceAmount,
+  SpeculosButton,
+} from "@ledgerhq/coin-framework/bot/specs";
+
+export const acceptTransaction: DeviceAction<Transaction, any> = deviceActionFlow({
+  steps: [
+    {
+      title: "Transaction Type",
+      button: SpeculosButton.RIGHT,
+      expectedValue: () => "Payment",
+    },
+    {
+      title: "Amount",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ account, status }) => formatDeviceAmount(account.currency, status.amount),
+    },
+    {
+      title: "Fee",
+      button: SpeculosButton.RIGHT,
+      expectedValue: ({ account, status }) =>
+        formatDeviceAmount(account.currency, status.estimatedFees),
+    },
+    {
+      title: "Destination",
+      button: SpeculosButton.RIGHT,
+      trimValue: true,
+      expectedValue: ({ transaction }) => transaction.recipient,
+    },
+    {
+      title: "Account",
+      button: SpeculosButton.RIGHT,
+      trimValue: true,
+      expectedValue: ({ account }) => account.freshAddress,
+    },
+    {
+      title: "Accept",
+      button: SpeculosButton.BOTH,
+    },
+    {
+      title: "Sign transaction",
+      button: SpeculosButton.BOTH,
+    },
+  ],
+});

package/src/test/bot-specs.ts

@@ -0,0 +1,76 @@
+/*
+
+import invariant from "invariant";
+import expect from "expect";
+import { DeviceModelId } from "@ledgerhq/devices";
+import type { AppSpec } from "@ledgerhq/coin-framework/bot/types";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+import { parseCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+import { botTest, genericTestDestination, pickSiblings } from "@ledgerhq/coin-framework/bot/specs";
+import { acceptTransaction } from "./bot-deviceActions";
+import type { Transaction } from "../types";
+
+const currency = getCryptoCurrencyById("boilerplate");
+const minAmountCutoff = parseCurrencyUnit(currency.units[0], "0.1");
+const reserve = parseCurrencyUnit(currency.units[0], "20");
+
+const boilerplateSpec: AppSpec<Transaction> = {
+  name: "BOILERPLATE",
+  currency,
+  appQuery: {
+    model: DeviceModelId.nanoS,
+    appName: "BOILERPLATE_APP_NAME",
+  },
+  genericDeviceAction: acceptTransaction,
+  minViableAmount: minAmountCutoff,
+  mutations: [
+    {
+      name: "move ~50%",
+      maxRun: 2,
+      testDestination: genericTestDestination,
+      transaction: ({ account, siblings, bridge, maxSpendable }) => {
+        invariant(maxSpendable.gt(minAmountCutoff), "balance is too low");
+        const transaction = bridge.createTransaction(account);
+        const sibling = pickSiblings(siblings, 3);
+        const recipient = sibling.freshAddress;
+        let amount = maxSpendable.div(1.9 + 0.2 * Math.random()).integerValue();
+
+        if (!sibling.used && amount.lt(reserve)) {
+          invariant(
+            maxSpendable.gt(reserve.plus(minAmountCutoff)),
+            "not enough funds to send to new account",
+          );
+          amount = reserve;
+        }
+
+        return {
+          transaction,
+          updates: [
+            {
+              amount,
+            },
+            {
+              recipient,
+            },
+            Math.random() > 0.5
+              ? {
+                  tag: 123,
+                }
+              : null,
+          ],
+        };
+      },
+      test: ({ account, accountBeforeTransaction, operation }) => {
+        botTest("account balance moved with operation.value", () =>
+          expect(account.balance.toString()).toBe(
+            accountBeforeTransaction.balance.minus(operation.value).toString(),
+          ),
+        );
+      },
+    },
+  ],
+};
+export default {
+  boilerplateSpec,
+};
+*/

package/src/test/bridgeDatasetTest.ts

@@ -0,0 +1,147 @@
+import BigNumber from "bignumber.js";
+import { DatasetTest } from "@ledgerhq/types-live";
+import { InvalidAddressBecauseDestinationIsAlsoSource } from "@ledgerhq/errors";
+import { fromTransactionRaw } from "../bridge/transaction";
+import { Transaction } from "../types";
+
+export const newAddress1 = "rZvBc5e2YR1A9otS3r9DyGh3NDP8XLLp4";
+
+export const dataset: DatasetTest<Transaction> = {
+  implementations: ["mock", "ripplejs"],
+  currencies: {
+    ripple: {
+      scanAccounts: [
+        {
+          name: "ripple seed 1",
+          unstableAccounts: true,
+          // our account is getting spammed...
+          apdus: `
+          => e00200400d038000002c8000009080000000
+          <= 2103c73f64083463fa923e1530af6f558204853873c6a45cbfb1f2f1e2ac2a5d989c2272734a4675764165634c333153513750594864504b6b3335625a456f78446d5231789000
+          => e002004015058000002c80000090800000000000000000000000
+          <= 2103d1adcff3e0cf1232b1416a75cd6f23b49dd6a25c69bc291a1f6783ec6825ec062272616765584842365134566276765764547a4b414e776a65435434485846434b58379000
+          => e002004015058000002c80000090800000010000000000000000
+          <= 21036da109ee84825eab0f55fb57bcf9ef0b05621e71fb0400266fb42d6f68f9487c2272425065393169766d67384347573450414e6f657555555173756d337470786a55469000
+          => e002004015058000002c80000090800000020000000000000000
+          <= 2102df9a55b79fb3668dac70fee7372806195841cd713ab8da9fba82240f9db8a23921725a76426335653259523141396f745333723944794768334e445038584c4c70349000
+          `,
+        },
+      ],
+      accounts: [
+        {
+          transactions: [
+            // FIXME
+
+            /*
+        {
+          name: "not enough spendable balance with base reserve",
+          transaction: fromTransactionRaw({
+            family: "xrp",
+            recipient: "rB6pwovsyrFWhPYUsjj9V3CHck985QjiXi",
+            amount: "15000000",
+            tag: null,
+            fee: "1",
+            feeCustomUnit: null,
+            networkInfo: null,
+          }),
+          expectedStatus: {
+            amount: BigNumber("15000000"),
+            estimatedFees: BigNumber("1"),
+            errors: {
+              amount: new NotEnoughSpendableBalance(null, {
+                minimumAmount: formatCurrencyUnit(
+                  rippleUnit,
+                  BigNumber("20"),
+                  {
+                    disableRounding: true,
+                    useGrouping: false,
+                    showCode: true,
+                  }
+                ),
+              }),
+            },
+            warnings: {},
+            totalSpent: BigNumber("15000001"),
+          },
+        },
+        */
+            // FIXME
+
+            /*
+        {
+          name: "operation amount to low to create the recipient account",
+          transaction: fromTransactionRaw({
+            family: "xrp",
+            recipient: newAddress1,
+            amount: "10000000",
+            tag: null,
+            fee: "1",
+            feeCustomUnit: null,
+            networkInfo: null
+          }),
+          expectedStatus: {
+            amount: BigNumber("10000000"),
+            estimatedFees: BigNumber("1"),
+            errors: {
+              amount: new NotEnoughBalanceBecauseDestinationNotCreated()
+            },
+            warnings: {},
+            totalSpent: BigNumber("10000001")
+          }
+        },
+        */
+            {
+              name: "recipient and sender must not be the same",
+              transaction: fromTransactionRaw({
+                family: "canton",
+                recipient: "rageXHB6Q4VbvvWdTzKANwjeCT4HXFCKX7",
+                amount: "10000000",
+                fee: "1",
+              }),
+              expectedStatus: {
+                amount: new BigNumber("10000000"),
+                estimatedFees: new BigNumber("1"),
+                errors: {
+                  recipient: new InvalidAddressBecauseDestinationIsAlsoSource(),
+                },
+                warnings: {},
+                totalSpent: new BigNumber("10000001"),
+              },
+            },
+            {
+              name: "Operation with tag succeed",
+              transaction: fromTransactionRaw({
+                family: "canton",
+                recipient: "rB6pwovsyrFWhPYUsjj9V3CHck985QjiXi",
+                amount: "10000000",
+                fee: "1",
+              }),
+              expectedStatus: {
+                amount: new BigNumber("10000000"),
+                estimatedFees: new BigNumber("1"),
+                errors: {},
+                warnings: {},
+                totalSpent: new BigNumber("10000001"),
+              },
+            },
+          ],
+          raw: {
+            id: "ripplejs:2:ripple:rageXHB6Q4VbvvWdTzKANwjeCT4HXFCKX7:",
+            seedIdentifier: "rageXHB6Q4VbvvWdTzKANwjeCT4HXFCKX7",
+            name: "XRP 1",
+            derivationMode: "",
+            index: 0,
+            freshAddress: "rageXHB6Q4VbvvWdTzKANwjeCT4HXFCKX7",
+            freshAddressPath: "44'/144'/0'/0/0",
+            blockHeight: 0,
+            operations: [],
+            pendingOperations: [],
+            currencyId: "ripple",
+            lastSyncDate: "",
+            balance: "21000310",
+          },
+        },
+      ],
+    },
+  },
+};

package/src/test/cli.ts

@@ -0,0 +1,44 @@
+import invariant from "invariant";
+import type { AccountLike } from "@ledgerhq/types-live";
+import type { Transaction } from "../types";
+import BigNumber from "bignumber.js";
+
+const options = [
+  {
+    name: "fee",
+    type: String,
+    desc: "how much fee",
+  },
+  {
+    name: "tag",
+    type: Number,
+    desc: "ripple tag",
+  },
+];
+
+function inferTransactions(
+  transactions: Array<{
+    account: AccountLike;
+    transaction: Transaction;
+  }>,
+  opts: { tag?: number | null | undefined; fee?: string },
+  {
+    inferAmount,
+  }: { inferAmount: (account: AccountLike, fee?: string) => BigNumber | null | undefined },
+): Transaction[] {
+  return transactions.flatMap(({ transaction, account }) => {
+    invariant(transaction.family === "canton", "Canton family");
+    return {
+      ...transaction,
+      fee: inferAmount(account, opts.fee || "0.001brp"),
+      tag: opts.tag,
+    };
+  });
+}
+
+export default function makeCliTools() {
+  return {
+    options,
+    inferTransactions,
+  };
+}

package/src/test/index.ts

@@ -0,0 +1,6 @@
+import makeCliTools from "./cli";
+
+export * from "./bridgeDatasetTest";
+export { makeCliTools };
+export * from "./bot-deviceActions";
+// export * from "./bot-specs";

package/src/types/bridge.ts

@@ -0,0 +1,33 @@
+import type { BigNumber } from "bignumber.js";
+import type { Unit } from "@ledgerhq/types-cryptoassets";
+import type {
+  TransactionCommon,
+  TransactionCommonRaw,
+  TransactionStatusCommon,
+  TransactionStatusCommonRaw,
+} from "@ledgerhq/types-live";
+
+export type NetworkInfo = {
+  family: "canton";
+  serverFee: BigNumber;
+  baseReserve: BigNumber;
+};
+
+export type NetworkInfoRaw = {
+  family: "canton";
+  serverFee: string;
+  baseReserve: string;
+};
+
+export type Transaction = TransactionCommon & {
+  family: "canton";
+  fee: BigNumber | null | undefined;
+};
+
+export type TransactionRaw = TransactionCommonRaw & {
+  family: "canton";
+  fee: string | null | undefined;
+};
+
+export type TransactionStatus = TransactionStatusCommon;
+export type TransactionStatusRaw = TransactionStatusCommonRaw;

package/src/types/errors.ts

@@ -0,0 +1,3 @@
+import { createCustomErrorClass } from "@ledgerhq/errors";
+
+export const SimulationError = createCustomErrorClass("SimulationError");