@ledgerhq/coin-internet_computer 1.4.0-nightly.0

package/src/bridge/index.ts

@@ -0,0 +1,63 @@
+import {
+  makeAccountBridgeReceive,
+  makeScanAccounts,
+  makeSync,
+} from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import resolver from "../signer";
+import getAddressWrapper from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import type { Account, AccountBridge, CurrencyBridge } from "@ledgerhq/types-live";
+import { defaultUpdateTransaction } from "@ledgerhq/coin-framework/bridge/jsHelpers";
+import type { Transaction, TransactionStatus, ICPSigner } from "../types";
+import { getTransactionStatus } from "./getTransactionStatus";
+import { estimateMaxSpendable } from "./estimateMaxSpendable";
+import { prepareTransaction } from "./prepareTransaction";
+import { createTransaction } from "./createTransaction";
+import { getAccountShape } from "./bridgeHelpers/account";
+import { buildSignOperation } from "./signOperation";
+import { broadcast } from "./broadcast";
+
+function buildCurrencyBridge(signerContext: SignerContext<ICPSigner>): CurrencyBridge {
+  const getAddress = resolver(signerContext);
+
+  const scanAccounts = makeScanAccounts({
+    getAccountShape,
+    getAddressFn: getAddressWrapper(getAddress),
+  });
+
+  return {
+    preload: () => Promise.resolve({}),
+    hydrate: () => {},
+    scanAccounts,
+  };
+}
+
+const sync = makeSync({ getAccountShape });
+
+function buildAccountBridge(
+  signerContext: SignerContext<ICPSigner>,
+): AccountBridge<Transaction, Account, TransactionStatus> {
+  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<ICPSigner>) {
+  return {
+    currencyBridge: buildCurrencyBridge(signerContext),
+    accountBridge: buildAccountBridge(signerContext),
+  };
+}

package/src/bridge/prepareTransaction.ts

@@ -0,0 +1,28 @@
+import { AccountBridge } from "@ledgerhq/types-live";
+import { Transaction } from "../types";
+import { getAddress, validateAddress } from "./bridgeHelpers/addresses";
+
+export const prepareTransaction: AccountBridge<Transaction>["prepareTransaction"] = async (
+  account,
+  transaction,
+) => {
+  // log("debug", "[prepareTransaction] start fn");
+
+  const { address } = getAddress(account);
+  const { recipient } = transaction;
+
+  let amount = transaction.amount;
+  if (recipient && address) {
+    // log("debug", "[prepareTransaction] fetching estimated fees");
+
+    if ((await validateAddress(recipient)).isValid && (await validateAddress(address)).isValid) {
+      if (transaction.useAllAmount) {
+        amount = account.spendableBalance.minus(transaction.fees);
+        return { ...transaction, amount };
+      }
+    }
+  }
+
+  // log("debug", "[prepareTransaction] finish fn");
+  return transaction;
+};

package/src/bridge/signOperation.ts

@@ -0,0 +1,59 @@
+import { Observable } from "rxjs";
+import { Account, AccountBridge } from "@ledgerhq/types-live";
+import { getAddress } from "./bridgeHelpers/addresses";
+import {
+  getTxnExpirationDate,
+  getTxnMetadata,
+  getUnsignedTransaction,
+  signICPTransaction,
+} from "./bridgeHelpers/icpRosetta";
+import { buildOptimisticOperation } from "./buildOptimisticOperation";
+import { Transaction } from "../types";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { ICPSigner } from "../types";
+import { getPath } from "../common-logic";
+
+export const buildSignOperation =
+  (signerContext: SignerContext<ICPSigner>): AccountBridge<Transaction, Account>["signOperation"] =>
+  ({ account, transaction, deviceId }) =>
+    new Observable(o => {
+      async function main() {
+        const { xpub } = account;
+        const { derivationPath } = getAddress(account);
+        const { unsignedTxn, payloads } = await getUnsignedTransaction(transaction, account);
+
+        o.next({
+          type: "device-signature-requested",
+        });
+
+        const { signedTxn } = await signICPTransaction({
+          signerContext,
+          deviceId,
+          unsignedTxn,
+          path: getPath(derivationPath),
+          payloads,
+          pubkey: xpub ?? "",
+        });
+
+        o.next({
+          type: "device-signature-granted",
+        });
+
+        const { hash } = await getTxnMetadata(signedTxn);
+        const operation = await buildOptimisticOperation(account, transaction, hash);
+
+        o.next({
+          type: "signed",
+          signedOperation: {
+            operation,
+            signature: signedTxn,
+            expirationDate: getTxnExpirationDate(unsignedTxn),
+          },
+        });
+      }
+
+      main().then(
+        () => o.complete(),
+        e => o.error(e),
+      );
+    });

package/src/bridge/transaction.ts

@@ -0,0 +1,61 @@
+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 { getAccountCurrency } from "@ledgerhq/coin-framework/account/index";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+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),
+    amount: new BigNumber(tr.amount),
+    memo: tr.memo,
+  };
+};
+
+const toTransactionRaw = (t: Transaction): TransactionRaw => {
+  const common = toTransactionCommonRaw(t);
+
+  return {
+    ...common,
+    family: t.family,
+    amount: t.amount.toFixed(),
+    fees: t.fees.toString(),
+    memo: t.memo,
+  };
+};
+
+export default {
+  formatTransaction,
+  fromTransactionRaw,
+  toTransactionRaw,
+  fromTransactionStatusRaw,
+  toTransactionStatusRaw,
+  formatTransactionStatus,
+};

package/src/common-logic/index.ts

@@ -0,0 +1,9 @@
+export {
+  getPath,
+  isValidHex,
+  isValidBase64,
+  methodToString,
+  getBufferFromString,
+  normalizeEpochTimestamp,
+  getRandomTransferID,
+} from "./utils";

package/src/common-logic/utils.ts

@@ -0,0 +1,47 @@
+import { BigNumber } from "bignumber.js";
+import { ICP_SEND_TXN_TYPE, MAX_MEMO_VALUE } from "../consts";
+
+const validHexRegExp = new RegExp(/[0-9A-Fa-f]{6}/g);
+const validBase64RegExp = new RegExp(
+  /^(?:[A-Za-z\d+/]{4})*(?:[A-Za-z\d+/]{3}=|[A-Za-z\d+/]{2}==)?$/,
+);
+
+export const getPath = (path: string): string =>
+  path && path.substr(0, 2) !== "m/" ? `m/${path}` : path;
+
+export const isValidHex = (msg: string): boolean => validHexRegExp.test(msg);
+export const isValidBase64 = (msg: string): boolean => validBase64RegExp.test(msg);
+
+export const methodToString = (method: number): string => {
+  switch (method) {
+    case ICP_SEND_TXN_TYPE:
+      return "Send ICP";
+    default:
+      return "Unknown";
+  }
+};
+
+export const getBufferFromString = (message: string): Buffer =>
+  isValidHex(message)
+    ? Buffer.from(message, "hex")
+    : isValidBase64(message)
+      ? Buffer.from(message, "base64")
+      : Buffer.from(message);
+
+export const normalizeEpochTimestamp = (timestamp: string): number => {
+  return parseInt(timestamp.slice(0, 13));
+};
+
+function randomIntFromInterval(min: any, max: any): string {
+  const minBig = new BigNumber(min);
+  const maxBig = new BigNumber(max);
+
+  const random = BigNumber.random().multipliedBy(maxBig.minus(minBig).plus(1)).plus(minBig);
+  const randomInt = random.integerValue(BigNumber.ROUND_FLOOR);
+
+  return randomInt.toString();
+}
+
+export function getRandomTransferID(): string {
+  return randomIntFromInterval(0, MAX_MEMO_VALUE);
+}

package/src/consts.ts

@@ -0,0 +1,11 @@
+export const ICP_SEND_TXN_TYPE = 0;
+
+// ICP Rosetta ids
+export const ICP_BLK_NAME_ROSETTA = "Internet Computer";
+export const ICP_NET_ID_ROSETTA = "00000000000000020101";
+
+// Mac ICP fees
+export const ICP_FEES = 1e4;
+
+// Max Memo value on ICP network
+export const MAX_MEMO_VALUE = Number.MAX_SAFE_INTEGER;

package/src/errors.ts

@@ -0,0 +1,6 @@
+import { createCustomErrorClass } from "@ledgerhq/errors";
+
+/*
+ * When the transferID/Memo is non number
+ */
+export const InvalidMemoICP = createCustomErrorClass("InvalidMemoICP");

package/src/hw-signMessage.ts

@@ -0,0 +1,42 @@
+import { log } from "@ledgerhq/logs";
+import { getBufferFromString } from "./common-logic/utils";
+import { ICP_SEND_TXN_TYPE } from "./consts";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { ICPSigner } from "./types";
+import { Account, AnyMessage } from "@ledgerhq/types-live";
+
+function bufferToArrayBuffer(buffer: Buffer): Buffer {
+  const sig = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+  return Buffer.from(sig);
+}
+
+export const signMessage =
+  (signerContext: SignerContext<ICPSigner>) =>
+  async (deviceId: string, account: Account, { message }: AnyMessage) => {
+    log("debug", "start signMessage process");
+
+    if (!message) throw new Error("Message cannot be empty");
+    if (typeof message !== "string") throw new Error("Message must be a string");
+
+    const { r } = await signerContext(deviceId, async signer => {
+      const r = await signer.sign(
+        account.freshAddressPath,
+        getBufferFromString(message),
+        ICP_SEND_TXN_TYPE,
+      );
+      return { r };
+    });
+
+    if (!r.signatureRS) {
+      throw Error("Signing failed");
+    }
+
+    return {
+      rsv: {
+        r: "",
+        s: "",
+        v: 0,
+      },
+      signature: bufferToArrayBuffer(r.signatureRS).toString("hex"),
+    };
+  };

package/src/signer/getAddress.ts

@@ -0,0 +1,34 @@
+import { log } from "@ledgerhq/logs";
+
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { GetAddressFn } from "@ledgerhq/coin-framework/bridge/getAddressWrapper";
+import { GetAddressOptions } from "@ledgerhq/coin-framework/derivation";
+import { ICPSigner } from "../types";
+
+function resolver(signerContext: SignerContext<ICPSigner>): GetAddressFn {
+  return async (deviceId: string, { path, verify }: GetAddressOptions) => {
+    log("debug", "start getAddress process");
+
+    const { r } = await signerContext(deviceId, async signer => {
+      const r = verify
+        ? await signer.showAddressAndPubKey(path)
+        : await signer.getAddressAndPubKey(path);
+
+      return { r };
+    });
+
+    if (!r.address || !r.publicKey) {
+      console.error("Failed to get address from device");
+      throw Error("Failed to get address from device");
+    }
+
+    return {
+      path,
+      address: Buffer.from(r.address).toString("hex"),
+      principalText: r.principalText,
+      publicKey: Buffer.from(r.publicKey).toString("hex"),
+    };
+  };
+}
+
+export default resolver;

package/src/signer/index.ts

@@ -0,0 +1,3 @@
+import resolver from "./getAddress";
+
+export default resolver;

package/src/test/bot-specs.ts

@@ -0,0 +1,120 @@
+import invariant from "invariant";
+import { DeviceModelId } from "@ledgerhq/devices";
+import expect from "expect";
+import BigNumber from "bignumber.js";
+import type { Transaction } from "../types";
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+import { genericTestDestination, pickSiblings, botTest } from "@ledgerhq/coin-framework/bot/specs";
+import type { AppSpec } from "@ledgerhq/coin-framework/bot/types";
+import { acceptTransaction } from "./speculos-deviceActions";
+import { getRandomTransferID } from "../common-logic/utils";
+
+const MIN_SAFE = new BigNumber(10);
+const maxAccount = 6;
+
+const internetComputerSpecs: AppSpec<Transaction> = {
+  name: "InternetComputer",
+  currency: getCryptoCurrencyById("internet_computer"),
+  appQuery: {
+    model: DeviceModelId.nanoS,
+    appName: "Internet Computer",
+  },
+  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: genericTestDestination,
+      transaction: ({ account, siblings, bridge, maxSpendable }) => {
+        invariant(maxSpendable.gt(MIN_SAFE), "balance is too low");
+        const sibling = pickSiblings(siblings, maxAccount);
+        const recipient = sibling.freshAddress;
+        const amount = maxSpendable.div(2).integerValue();
+
+        const transaction = bridge.createTransaction(account);
+        const updates: Array<Partial<Transaction>> = [
+          {
+            recipient,
+          },
+          { amount },
+        ];
+
+        if (Math.random() < 0.5) {
+          updates.push({
+            memo: getRandomTransferID(),
+          });
+        }
+
+        return {
+          transaction,
+          updates,
+        };
+      },
+
+      test: ({ accountBeforeTransaction, operation, account, transaction }) => {
+        botTest("account spendable balance decreased with operation", () =>
+          expect(account.spendableBalance).toEqual(
+            accountBeforeTransaction.spendableBalance.minus(operation.value),
+          ),
+        );
+
+        if (transaction.memo) {
+          botTest("operation memo", () =>
+            expect(operation.extra).toMatchObject({
+              memo: transaction.memo,
+            }),
+          );
+        }
+      },
+    },
+    {
+      name: "Transfer Max",
+      maxRun: 1,
+      testDestination: genericTestDestination,
+      transaction: ({ account, siblings, bridge }) => {
+        const transaction = bridge.createTransaction(account);
+        const updates: Array<Partial<Transaction>> = [
+          {
+            recipient: pickSiblings(siblings, maxAccount).freshAddress,
+          },
+          {
+            useAllAmount: true,
+          },
+        ];
+
+        if (Math.random() < 0.5) {
+          updates.push({
+            memo: getRandomTransferID(),
+          });
+        }
+
+        return {
+          transaction,
+          updates,
+        };
+      },
+      test: ({ account, transaction, operation }) => {
+        botTest("account spendable balance is zero", () =>
+          expect(account.spendableBalance.toString()).toBe("0"),
+        );
+
+        if (transaction.memo) {
+          botTest("operation memo", () =>
+            expect(operation.extra).toMatchObject({
+              memo: transaction.memo,
+            }),
+          );
+        }
+      },
+    },
+  ],
+};
+
+export default {
+  internetComputerSpecs,
+};

package/src/test/bridgeDatasetTest.ts

@@ -0,0 +1,141 @@
+import type { CurrenciesData, DatasetTest } from "@ledgerhq/types-live";
+import type { Transaction } from "../types";
+import { fromTransactionRaw } from "../bridge/transaction";
+import BigNumber from "bignumber.js";
+import { AmountRequired, InvalidAddress, NotEnoughBalance } from "@ledgerhq/errors";
+import { getEstimatedFees } from "../bridge/bridgeHelpers/fee";
+import { InvalidMemoICP } from "../errors";
+
+const SEED_IDENTIFIER =
+  "046f08828871028b6e3cb5c13b2e2a8fa6e93f0b3ca7379171f6b7b45877955a2430925f76ec69ccb3cd8738859a8e29dcd0f9a357f1d009d2b497c6c8f63aa7cf";
+
+// const SEED_IDENTIFIER_ADDRESS = "e8a1474afbed438be8b019c4293b9e01b33075d72757ac715183ae7c7ba77e37";
+const ACCOUNT_2 = "fdb7db0d3ae67368cb5010b7de7d98566c072f0a4eda871f45cd6582bf08aeb4";
+
+const internet_computer: CurrenciesData<Transaction> = {
+  scanAccounts: [
+    {
+      name: "internet_computer seed 1",
+      apdus: `
+      => 11010000142c000080df000080000000800000000000000000
+      <= 046f08828871028b6e3cb5c13b2e2a8fa6e93f0b3ca7379171f6b7b45877955a2430925f76ec69ccb3cd8738859a8e29dcd0f9a357f1d009d2b497c6c8f63aa7cf182d2af0e048c8cf215fa86d7af7e2234f401679c7839dd3b1ae916a02e8a1474afbed438be8b019c4293b9e01b33075d72757ac715183ae7c7ba77e37793471646770797966757670627963697a646873637835696e763570707972646a3561626d366f68716f6f35686d6e6f73667661659000
+      => 11010000142c000080df000080000000800000000001000000
+      <= 043ad9dda46b25cbcf98b2d91f8aa289d08078fa960d13e7d77a571c625eedcb62b6c26a86408d30a6bbdea5ecad6f7603bc1ba11fbb62caa315789f333ece2c8cd785035623de419beb00247d11fbb4d3f77fbb466869fb01deac4f61021723b9a25b7cb1865caa6e633fc727c95cee6a84c52e5ca0f8752ecf66cdea4b6764756f79346f78717562766d69363669676e367761626570756937786e677436353733777274696e6835716478766d6a357171659000
+      `,
+      test: (expect, accounts) => {
+        for (const account of accounts) {
+          expect(account.derivationMode).toEqual("internet_computer");
+        }
+      },
+    },
+  ],
+  accounts: [
+    {
+      raw: {
+        id: `js:2:internet_computer:${SEED_IDENTIFIER}:`,
+        balance: "1000000",
+        currencyId: "internet_computer",
+        derivationMode: "internet_computer",
+        freshAddress: "",
+        freshAddressPath: "44'/223'/0'/0/0",
+        index: 0,
+        name: "Internet Computer 1",
+        operationsCount: 1,
+        blockHeight: 0,
+        pendingOperations: [],
+        operations: [],
+        lastSyncDate: "",
+        seedIdentifier: SEED_IDENTIFIER,
+        spendableBalance: "1000000",
+        swapHistory: [],
+        syncHash: undefined,
+        used: true,
+        xpub: SEED_IDENTIFIER,
+      },
+      transactions: [
+        {
+          name: "Not a valid address",
+          transaction: fromTransactionRaw({
+            family: "internet_computer",
+            recipient: "novalidaddress",
+            fees: getEstimatedFees().toString(),
+            amount: "1000",
+          }),
+          expectedStatus: {
+            errors: {
+              recipient: new InvalidAddress(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "Not enough balance",
+          transaction: fromTransactionRaw({
+            family: "internet_computer",
+            recipient: ACCOUNT_2,
+            fees: getEstimatedFees().toString(),
+            amount: (300 * 1e9).toString(),
+          }),
+          expectedStatus: {
+            errors: {
+              amount: new NotEnoughBalance(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "Invalid transferID/Memo",
+          transaction: fromTransactionRaw({
+            family: "internet_computer",
+            recipient: ACCOUNT_2,
+            fees: getEstimatedFees().toString(),
+            amount: "1000",
+            memo: "-1",
+          }),
+          expectedStatus: {
+            errors: {
+              transaction: new InvalidMemoICP(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "Amount Required",
+          transaction: fromTransactionRaw({
+            family: "internet_computer",
+            recipient: ACCOUNT_2,
+            amount: "0",
+            fees: getEstimatedFees().toString(),
+          }),
+          expectedStatus: {
+            errors: {
+              amount: new AmountRequired(),
+            },
+            warnings: {},
+          },
+        },
+        {
+          name: "New account and sufficient amount",
+          transaction: fromTransactionRaw({
+            family: "internet_computer",
+            recipient: ACCOUNT_2,
+            amount: "1000",
+            fees: getEstimatedFees().toString(),
+          }),
+          expectedStatus: {
+            amount: new BigNumber("1000"),
+            errors: {},
+            warnings: {},
+          },
+        },
+      ],
+    },
+  ],
+};
+
+export const dataset: DatasetTest<Transaction> = {
+  implementations: ["js"],
+  currencies: {
+    internet_computer,
+  },
+};

package/src/test/cli.ts

@@ -0,0 +1,36 @@
+import type { Account, AccountLike, AccountLikeArray } from "@ledgerhq/types-live";
+import invariant from "invariant";
+import flatMap from "lodash/flatMap";
+import type { Transaction } from "../types";
+
+function inferAccounts(account: Account): AccountLikeArray {
+  invariant(account.currency.family === "internet_computer", "internet computer family");
+
+  const accounts: Account[] = [account];
+  return accounts;
+}
+
+function inferTransactions(
+  transactions: Array<{
+    account: AccountLike;
+    transaction: Transaction;
+    mainAccount: Account;
+  }>,
+): Transaction[] {
+  return flatMap(transactions, ({ transaction }) => {
+    invariant(transaction.family === "internet_computer", "internet computer family");
+
+    return {
+      ...transaction,
+      family: "internet_computer",
+    } as Transaction;
+  });
+}
+
+export default function makeCliTools() {
+  return {
+    options: [],
+    inferAccounts,
+    inferTransactions,
+  };
+}

package/src/test/index.ts

@@ -0,0 +1,3 @@
+export * from "./bridgeDatasetTest";
+export * from "./bot-specs";
+export * from "./speculos-deviceActions";