@ledgerhq/live-common 31.2.0 → 31.3.0-next.0

package/src/families/internet_computer/bridge/bridgeHelpers/icpRosetta/index.ts

@@ -0,0 +1,134 @@
+import Transport from "@ledgerhq/hw-transport";
+import { Account } from "@ledgerhq/types-live";
+import { Transaction } from "../../../types";
+import ICP from "@zondax/ledger-icp";
+import { constructionInvoke, getICPRosettaNetworkIdentifier } from "../api";
+import {
+  ICPRosettaConstructionCombineRequest,
+  ICPRosettaConstructionCombineResponse,
+  ICPRosettaConstructionHashRequest,
+  ICPRosettaConstructionHashResponse,
+  ICPRosettaConstructionPayloadsRequest,
+  ICPRosettaConstructionPayloadsResponse,
+  ICPRosettaConstructionSubmitRequest,
+  ICPRosettaConstructionSubmitResponse,
+} from "./types";
+import { ingressExpiry, generateOperations, generateSignaturesPayload } from "./utils";
+import { Cbor } from "@dfinity/agent";
+import { Principal } from "@dfinity/principal";
+import { isError } from "../../../utils";
+import BigNumber from "bignumber.js";
+
+export const getUnsignedTransaction = async (
+  transaction: Transaction,
+  account: Account,
+): Promise<{
+  unsignedTxn: string;
+  payloads: ICPRosettaConstructionPayloadsResponse["payloads"];
+}> => {
+  const ops = generateOperations(transaction, account);
+  const pubkeys = [
+    {
+      hex_bytes: account.xpub ?? "",
+      curve_type: "secp256k1",
+    },
+  ];
+
+  const reqOpts: ICPRosettaConstructionPayloadsRequest = {
+    ...getICPRosettaNetworkIdentifier(),
+    operations: ops,
+    public_keys: pubkeys,
+    metadata: {
+      memo: parseInt(transaction.memo ?? "0"),
+    },
+  };
+  const { payloads, unsigned_transaction } = await constructionInvoke<
+    ICPRosettaConstructionPayloadsRequest,
+    ICPRosettaConstructionPayloadsResponse
+  >(reqOpts, "payloads");
+
+  return { unsignedTxn: unsigned_transaction, payloads };
+};
+
+export const signICPTransaction = async ({
+  unsignedTxn,
+  transport,
+  path,
+  payloads,
+  pubkey,
+}: {
+  unsignedTxn: string;
+  transport: Transport;
+  path: string;
+  payloads: ICPRosettaConstructionPayloadsResponse["payloads"];
+  pubkey: string;
+}): Promise<{
+  signatures: { txnSig: string; readSig: string };
+  signedTxn: string;
+}> => {
+  const icp = new ICP(transport);
+  const decodedTxn: any = Cbor.decode(Buffer.from(unsignedTxn, "hex"));
+  const txnReqFromCbor = decodedTxn.updates[0][1];
+  const expiry = new ingressExpiry(BigNumber(decodedTxn.ingress_expiries[0].toString()));
+
+  const submitReq = {
+    request_type: "call",
+    canister_id: Principal.fromUint8Array(txnReqFromCbor.canister_id),
+    method_name: txnReqFromCbor.method_name,
+    arg: txnReqFromCbor.arg,
+    sender: Principal.fromUint8Array(txnReqFromCbor.sender),
+    ingress_expiry: expiry,
+  };
+
+  const txnBlobToSign = Cbor.encode({
+    content: submitReq,
+  });
+
+  const signedTxnRes = await icp.sign(path, Buffer.from(txnBlobToSign), 0);
+  isError(signedTxnRes);
+
+  const result = {
+    signatures: {
+      readSig: "",
+      txnSig: Buffer.from(signedTxnRes.signatureRS ?? "").toString("hex"),
+    },
+  };
+
+  const signaturesPayload = generateSignaturesPayload(result.signatures, payloads, pubkey);
+
+  const { signed_transaction: signedTxn } = await constructionInvoke<
+    ICPRosettaConstructionCombineRequest,
+    ICPRosettaConstructionCombineResponse
+  >(
+    {
+      ...getICPRosettaNetworkIdentifier(),
+      signatures: signaturesPayload,
+      unsigned_transaction: unsignedTxn,
+    },
+    "combine",
+  );
+
+  return { ...result, signedTxn };
+};
+
+export const getTxnMetadata = async (signedTxn: string): Promise<{ hash: string }> => {
+  const {
+    transaction_identifier: { hash },
+  } = await constructionInvoke<
+    ICPRosettaConstructionHashRequest,
+    ICPRosettaConstructionHashResponse
+  >({ ...getICPRosettaNetworkIdentifier(), signed_transaction: signedTxn }, "hash");
+
+  return { hash };
+};
+
+export const getTxnExpirationDate = (_unsignedTxn: string): Date => {
+  return new Date();
+};
+
+export const broadcastTxn = async (signedTxn: string) => {
+  await constructionInvoke<
+    ICPRosettaConstructionSubmitRequest,
+    ICPRosettaConstructionSubmitResponse
+  >({ ...getICPRosettaNetworkIdentifier(), signed_transaction: signedTxn }, "submit");
+};

package/src/families/internet_computer/bridge/bridgeHelpers/icpRosetta/types.ts

@@ -0,0 +1,157 @@
+import { SubmitResponse } from "@dfinity/agent";
+
+export interface ICPRosettaBlockHeightResponse {
+  current_block_identifier: ICPRosettaBlockIdentifier;
+  current_block_timestamp: number;
+  genesis_block_identifier: ICPRosettaBlockIdentifier;
+  sync_status: ICPRosettaSyncstatus;
+  peers: any[];
+}
+
+interface ICPRosettaBlockIdentifier {
+  index: number;
+  hash: string;
+}
+
+export interface ICPRosettaGetBalancesResponse {
+  block_identifier: ICPRosettaBlockIdentifier;
+  balances: ICPRosettaBalance[];
+  details?: { error_message: string };
+}
+
+interface ICPRosettaBalance {
+  value: string;
+  currency: ICPRosettaCurrency;
+}
+
+interface ICPRosettaCurrency {
+  symbol: string;
+  decimals: number;
+}
+
+interface ICPRosettaSyncstatus {
+  current_index: number;
+  target_index: number;
+}
+
+export interface ICPRosettaGetTxnsHistoryResponse {
+  transactions: {
+    block_identifier: ICPRosettaBlockIdentifier;
+    transaction: {
+      transaction_identifier: ICPRosettaTransactionidentifier;
+      operations: ICPRosettaICPRosettaOperation[];
+      metadata: {
+        block_height: number;
+        memo: number;
+        timestamp: number;
+      };
+    };
+  }[];
+  total_count: number;
+}
+
+export interface ICPRosettaICPRosettaOperation {
+  operation_identifier: {
+    index: number;
+  };
+  type: string;
+  status?: string;
+  account: ICPRosettaAccountIdentifier;
+  amount: ICPRosettaBalance;
+  metadata?: {
+    block_index: number;
+    transaction_identifier: ICPRosettaTransactionidentifier;
+  };
+}
+
+export interface ICPRosettaConstructionPayloadsRequest {
+  network_identifier: ICPRosettaNetworkIdentifier;
+  operations: ICPRosettaICPRosettaOperation[];
+  metadata?: ICPRosettaMetadata;
+  public_keys: ICPRosettaPublickey[];
+}
+
+export interface ICPRosettaPublickey {
+  hex_bytes: string;
+  curve_type: string;
+}
+
+export interface ICPRosettaMetadata {
+  memo?: number;
+  created_at?: number;
+  ingress_end?: number;
+  ingress_start?: number;
+}
+
+interface ICPRosettaCurrency {
+  symbol: string;
+  decimals: number;
+}
+
+interface ICPRosettaNetworkIdentifier {
+  blockchain: string;
+  network: string;
+}
+
+export interface ICPRosettaConstructionPayloadsResponse {
+  unsigned_transaction: string;
+  payloads: {
+    account_identifier: ICPRosettaAccountIdentifier;
+    hex_bytes: string;
+    signature_type: string;
+  }[];
+}
+
+interface ICPRosettaAccountIdentifier {
+  address: string;
+}
+
+export interface ICPRosettaConstructionCombineRequest {
+  network_identifier: ICPRosettaNetworkIdentifier;
+  unsigned_transaction: string; // cbor
+  signatures: ICPRosettaSignature[];
+}
+
+export interface ICPRosettaSignature {
+  signing_payload: {
+    account_identifier: ICPRosettaAccountIdentifier;
+    hex_bytes: string;
+    signature_type: string;
+  };
+  public_key: ICPRosettaPublickey;
+  signature_type: string;
+  hex_bytes: string;
+}
+
+export interface ICPRosettaConstructionCombineResponse {
+  signed_transaction: string;
+}
+
+export interface ICPRosettaConstructionSubmitRequest {
+  network_identifier: ICPRosettaNetworkIdentifier;
+  signed_transaction: string;
+}
+export interface ICPRosettaConstructionSubmitResponse {
+  transaction_identifier: ICPRosettaTransactionidentifier;
+  metadata: {
+    operations: ICPRosettaICPRosettaOperation[];
+  };
+}
+
+interface ICPRosettaTransactionidentifier {
+  hash: string;
+}
+
+export interface ICPRosettaConstructionHashRequest {
+  network_identifier: ICPRosettaNetworkIdentifier;
+  signed_transaction: string;
+}
+
+export interface ICPRosettaConstructionHashResponse {
+  transaction_identifier: ICPRosettaTransactionidentifier;
+}
+
+export interface ICPRosettaBroadcastResult extends SubmitResponse {
+  txnHash?: string;
+  blockHeight?: string;
+}

package/src/families/internet_computer/bridge/bridgeHelpers/icpRosetta/utils.ts

@@ -0,0 +1,151 @@
+import * as cbor from "simple-cbor";
+import {
+  ICPRosettaConstructionCombineRequest,
+  ICPRosettaConstructionPayloadsResponse,
+  ICPRosettaICPRosettaOperation,
+} from "./types";
+import { PipeArrayBuffer } from "@dfinity/candid";
+import BigInteger from "big-integer";
+import { Transaction } from "../../../types";
+import { Account } from "@ledgerhq/types-live";
+import { getAddress } from "../addresses";
+import BigNumber from "bignumber.js";
+
+export const generateOperations = (
+  tr: Transaction,
+  a: Account,
+): ICPRosettaICPRosettaOperation[] => {
+  const { address } = getAddress(a);
+  const currency = {
+    symbol: "ICP",
+    decimals: 8,
+  };
+  const type = "TRANSACTION";
+  const operations: ICPRosettaICPRosettaOperation[] = [];
+  operations.push({
+    operation_identifier: {
+      index: 0,
+    },
+    type,
+    account: {
+      address,
+    },
+    amount: {
+      value: `-${tr.amount}`,
+      currency,
+    },
+  });
+
+  operations.push({
+    operation_identifier: {
+      index: 1,
+    },
+    type,
+    account: {
+      address: tr.recipient,
+    },
+    amount: {
+      value: `${tr.amount}`,
+      currency,
+    },
+  });
+
+  operations.push({
+    operation_identifier: {
+      index: 2,
+    },
+    type: "FEE",
+    account: {
+      address,
+    },
+    amount: {
+      value: `-${tr.fees}`,
+      currency,
+    },
+  });
+
+  return operations;
+};
+
+function expiryEncode(val: BigNumber): ArrayBuffer {
+  let value = BigInteger(val.toString());
+
+  if (value < BigInteger(0)) {
+    throw new Error("Cannot leb encode negative values.");
+  }
+
+  const byteLength = (value === BigInteger(0) ? 0 : Math.ceil(Math.log2(Number(value)))) + 1;
+  const pipe = new PipeArrayBuffer(new ArrayBuffer(byteLength), 0);
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    const i = Number(value.and(BigInteger(0x7f)));
+    value = value.divide(BigInteger(0x80));
+    if (value.eq(BigInteger(0))) {
+      pipe.write(new Uint8Array([i]));
+      break;
+    } else {
+      pipe.write(new Uint8Array([i | 0x80]));
+    }
+  }
+
+  return pipe.buffer;
+}
+
+export class ingressExpiry {
+  value: BigNumber;
+
+  constructor(value: BigNumber) {
+    // Use bigint because it can overflow the maximum number allowed in a double float.
+    this.value = value;
+  }
+
+  public toCBOR(): cbor.CborValue {
+    return cbor.value.u64(this.value.toString(16), 16);
+  }
+
+  public toHash(): ArrayBuffer {
+    return expiryEncode(this.value);
+  }
+}
+
+export const generateSignaturesPayload = (
+  signs: { txnSig: string; readSig: string },
+  payloads: ICPRosettaConstructionPayloadsResponse["payloads"],
+  pubkey: string,
+): ICPRosettaConstructionCombineRequest["signatures"] => {
+  const signatures: ICPRosettaConstructionCombineRequest["signatures"] = [];
+  const [txnPayload, readStatePayload] = payloads;
+  signatures.push({
+    signing_payload: {
+      account_identifier: {
+        address: txnPayload.account_identifier.address,
+      },
+      hex_bytes: txnPayload.hex_bytes,
+      signature_type: txnPayload.signature_type,
+    },
+    public_key: {
+      hex_bytes: pubkey,
+      curve_type: "secp256k1",
+    },
+    signature_type: "ecdsa",
+    hex_bytes: signs.txnSig,
+  });
+
+  signatures.push({
+    signing_payload: {
+      account_identifier: {
+        address: readStatePayload.account_identifier.address,
+      },
+      hex_bytes: readStatePayload.hex_bytes,
+      signature_type: readStatePayload.signature_type,
+    },
+    public_key: {
+      hex_bytes: pubkey,
+      curve_type: "secp256k1",
+    },
+    signature_type: "ecdsa",
+    hex_bytes: signs.readSig,
+  });
+
+  return signatures;
+};

package/src/families/internet_computer/bridge/currency.ts

@@ -0,0 +1,11 @@
+import { makeScanAccounts } from "../../../bridge/jsHelpers";
+import { getAccountShape } from "./bridgeHelpers/account";
+import { CurrencyBridge } from "@ledgerhq/types-live";
+
+const scanAccounts = makeScanAccounts({ getAccountShape });
+
+export const currencyBridge: CurrencyBridge = {
+  preload: () => Promise.resolve({}),
+  hydrate: () => {},
+  scanAccounts,
+};

package/src/families/internet_computer/bridge/js.ts

@@ -0,0 +1,7 @@
+import { currencyBridge } from "./currency";
+import { accountBridge } from "./account";
+
+export default {
+  currencyBridge,
+  accountBridge,
+};

package/src/families/internet_computer/bridge.integration.test.ts

@@ -0,0 +1,150 @@
+import "../../__tests__/test-helpers/setup";
+import { testBridge } from "../../__tests__/test-helpers/bridge";
+import type { CurrenciesData, DatasetTest } from "@ledgerhq/types-live";
+import type { Transaction } from "./types";
+import { fromTransactionRaw } from "./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 =
+// "e8a1474afbed438be8b019c4293b9e01b33075d72757ac715183ae7c7ba77e37";
+const ACCOUNT_2 = "fdb7db0d3ae67368cb5010b7de7d98566c072f0a4eda871f45cd6582bf08aeb4";
+
+const internet_computer: CurrenciesData<Transaction> = {
+  scanAccounts: [
+    {
+      name: "internet_computer seed 1",
+      apdus: `
+      => 11010000142c000080df000080000000800000000000000000
+      <= 046f08828871028b6e3cb5c13b2e2a8fa6e93f0b3ca7379171f6b7b45877955a2430925f76ec69ccb3cd8738859a8e29dcd0f9a357f1d009d2b497c6c8f63aa7cf182d2af0e048c8cf215fa86d7af7e2234f401679c7839dd3b1ae916a02e8a1474afbed438be8b019c4293b9e01b33075d72757ac715183ae7c7ba77e37793471646770797966757670627963697a646873637835696e763570707972646a3561626d366f68716f6f35686d6e6f73667661659000
+      => 11010000142c000080df000080000000800000000001000000
+      <= 043ad9dda46b25cbcf98b2d91f8aa289d08078fa960d13e7d77a571c625eedcb62b6c26a86408d30a6bbdea5ecad6f7603bc1ba11fbb62caa315789f333ece2c8cd785035623de419beb00247d11fbb4d3f77fbb466869fb01deac4f61021723b9a25b7cb1865caa6e633fc727c95cee6a84c52e5ca0f8752ecf66cdea4b6764756f79346f78717562766d69363669676e367761626570756937786e677436353733777274696e6835716478766d6a357171659000
+      => 11010000142c000080df000080010000800000000000000000
+      <= 04fc89df2bb2677347117b550c9a66b9a54c384dfee78a83a1e3010fd2f5ce7418f6706102bc5611094702f64773fd5569ca5e24c44b77383e58e034f521f96bafe7b69dcf5141bfb119194185a296a11aa33c986f48369fac7ec6571b0202c1bf9b7b539ad8e39cf4df4881742be4fa2c4a6b1b97c1b735972665556742706e756a7566786877326f3436756b627836797273676b627177726a6e696932756d366a7133326967327032793777676b346e71659000
+      `,
+    },
+  ],
+  accounts: [
+    {
+      raw: {
+        balance: "1000000",
+        currencyId: "internet_computer",
+        derivationMode: "",
+        freshAddress: "e8a1474afbed438be8b019c4293b9e01b33075d72757ac715183ae7c7ba77e37",
+        freshAddressPath: "44'/223'/0'/0/0",
+        freshAddresses: [
+          {
+            address: "e8a1474afbed438be8b019c4293b9e01b33075d72757ac715183ae7c7ba77e37",
+            derivationPath: "44'/223'/0'/0/0",
+          },
+        ],
+        id: "js:2:internet_computer:046f08828871028b6e3cb5c13b2e2a8fa6e93f0b3ca7379171f6b7b45877955a2430925f76ec69ccb3cd8738859a8e29dcd0f9a357f1d009d2b497c6c8f63aa7cf:",
+        index: 0,
+        name: "Internet Computer 1",
+        nfts: undefined,
+        operationsCount: 1,
+        blockHeight: 0,
+        pendingOperations: [],
+        operations: [],
+        lastSyncDate: "",
+        seedIdentifier:
+          "046f08828871028b6e3cb5c13b2e2a8fa6e93f0b3ca7379171f6b7b45877955a2430925f76ec69ccb3cd8738859a8e29dcd0f9a357f1d009d2b497c6c8f63aa7cf",
+        spendableBalance: "1000000",
+        starred: false,
+        swapHistory: [],
+        syncHash: undefined,
+        unitMagnitude: 8,
+        used: true,
+        xpub: "046f08828871028b6e3cb5c13b2e2a8fa6e93f0b3ca7379171f6b7b45877955a2430925f76ec69ccb3cd8738859a8e29dcd0f9a357f1d009d2b497c6c8f63aa7cf",
+      },
+      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: {},
+          },
+        },
+      ],
+    },
+  ],
+};
+
+const dataset: DatasetTest<Transaction> = {
+  implementations: ["js"],
+  currencies: {
+    internet_computer,
+  },
+};
+
+testBridge(dataset);

package/src/families/internet_computer/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/families/internet_computer/deviceTransactionConfig.ts

@@ -0,0 +1,52 @@
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+import { log } from "@ledgerhq/logs";
+import { Account, AccountLike } from "@ledgerhq/types-live";
+import { formatCurrencyUnit } from "../../currencies";
+import type { DeviceTransactionField } from "../../transaction";
+import { Transaction, TransactionStatus } from "./types";
+import { methodToString } from "./utils";
+
+const currency = getCryptoCurrencyById("internet_computer");
+
+function getDeviceTransactionConfig({
+  transaction,
+}: {
+  account: AccountLike;
+  parentAccount: Account | null | undefined;
+  transaction: Transaction;
+  status: TransactionStatus;
+}): Array<DeviceTransactionField> {
+  const fields: Array<DeviceTransactionField> = [];
+  fields.push({
+    type: "text",
+    label: "Transaction Type",
+    value: methodToString(0),
+  });
+  fields.push({
+    type: "text",
+    label: "Payment (ICP)",
+    value: formatCurrencyUnit(currency.units[0], transaction.amount, {
+      showCode: false,
+      disableRounding: true,
+    }),
+  });
+  fields.push({
+    type: "text",
+    label: "Maximum fee (ICP)",
+    value: formatCurrencyUnit(currency.units[0], transaction.fees, {
+      showCode: false,
+      disableRounding: true,
+    }),
+  });
+  fields.push({
+    type: "text",
+    label: "Memo",
+    value: transaction.memo ?? "0",
+  });
+
+  log("debug", `Transaction config ${JSON.stringify(fields)}`);
+
+  return fields;
+}
+
+export default getDeviceTransactionConfig;

package/src/families/internet_computer/errors.ts

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