@ledgerhq/coin-internet_computer 1.4.0-nightly.0

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

@@ -0,0 +1,154 @@
+import { Account } from "@ledgerhq/types-live";
+import { Transaction } from "../../../types";
+import { constructionInvoke, getICPRosettaNetworkIdentifier } from "../../../api";
+import {
+  ICPRosettaConstructionCombineRequest,
+  ICPRosettaConstructionCombineResponse,
+  ICPRosettaConstructionHashRequest,
+  ICPRosettaConstructionHashResponse,
+  ICPRosettaConstructionPayloadsRequest,
+  ICPRosettaConstructionPayloadsResponse,
+  ICPRosettaConstructionSubmitRequest,
+  ICPRosettaConstructionSubmitResponse,
+  ICPRosettaConstructionDeriveRequest,
+  ICPRosettaConstructionDeriveResponse,
+} from "./types";
+import { ingressExpiry, generateOperations, generateSignaturesPayload } from "./utils";
+import { Cbor } from "@dfinity/agent";
+import { Principal } from "@dfinity/principal";
+import BigNumber from "bignumber.js";
+import { ICP_SEND_TXN_TYPE } from "../../../consts";
+import { SignerContext } from "@ledgerhq/coin-framework/signer";
+import { ICPSigner } from "../../../types";
+
+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 ({
+  signerContext,
+  deviceId,
+  unsignedTxn,
+  path,
+  payloads,
+  pubkey,
+}: {
+  signerContext: SignerContext<ICPSigner>;
+  deviceId: string;
+  unsignedTxn: string;
+  path: string;
+  payloads: ICPRosettaConstructionPayloadsResponse["payloads"];
+  pubkey: string;
+}): Promise<{
+  signatures: { txnSig: string; readSig: string };
+  signedTxn: string;
+}> => {
+  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 { r } = await signerContext(deviceId, async signer => {
+    const r = await signer.sign(path, Buffer.from(txnBlobToSign), ICP_SEND_TXN_TYPE);
+    return { r };
+  });
+
+  const result = {
+    signatures: {
+      readSig: "",
+      txnSig: Buffer.from(r.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");
+};
+
+export const deriveAddressFromPubkey = async (pubkey: string) => {
+  const res = await constructionInvoke<
+    ICPRosettaConstructionDeriveRequest,
+    ICPRosettaConstructionDeriveResponse
+  >(
+    {
+      ...getICPRosettaNetworkIdentifier(),
+      public_key: { curve_type: "secp256k1", hex_bytes: pubkey },
+    },
+    "derive",
+  );
+
+  return res.account_identifier.address;
+};

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

@@ -0,0 +1,166 @@
+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;
+}
+
+export interface ICPRosettaConstructionDeriveRequest {
+  network_identifier: ICPRosettaNetworkIdentifier;
+  public_key: ICPRosettaPublickey;
+}
+
+export interface ICPRosettaConstructionDeriveResponse {
+  account_identifier: ICPRosettaAccountIdentifier;
+}

package/src/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/bridge/broadcast.ts

@@ -0,0 +1,15 @@
+import { AccountBridge } from "@ledgerhq/types-live";
+import { broadcastTxn } from "./bridgeHelpers/icpRosetta";
+import { Transaction } from "../types";
+
+export const broadcast: AccountBridge<Transaction>["broadcast"] = async ({
+  signedOperation: { signature, operation },
+}) => {
+  // log("debug", "[broadcast] start fn");
+
+  await broadcastTxn(signature);
+
+  const result = { ...operation };
+
+  return result;
+};

package/src/bridge/buildOptimisticOperation.ts

@@ -0,0 +1,32 @@
+import { Account, OperationType } from "@ledgerhq/types-live";
+import { encodeOperationId } from "@ledgerhq/coin-framework/operation";
+import { InternetComputerOperation, Transaction } from "../types";
+import { getAddress } from "./bridgeHelpers/addresses";
+
+export const buildOptimisticOperation = async (
+  account: Account,
+  transaction: Transaction,
+  hash: string,
+  operationType: OperationType = "OUT",
+): Promise<InternetComputerOperation> => {
+  const { id: accountId } = account;
+  const { recipient, amount } = transaction;
+  const { address } = getAddress(account);
+
+  return {
+    id: encodeOperationId(accountId, hash, operationType),
+    hash,
+    type: "OUT",
+    senders: [address],
+    recipients: [recipient],
+    accountId,
+    value: amount.plus(transaction.fees),
+    fee: transaction.fees,
+    blockHash: null,
+    blockHeight: null,
+    date: new Date(),
+    extra: {
+      memo: transaction.memo,
+    },
+  };
+};

package/src/bridge/createTransaction.ts

@@ -0,0 +1,15 @@
+import { AccountBridge } from "@ledgerhq/types-live";
+import { Transaction } from "../types";
+import BigNumber from "bignumber.js";
+import { getEstimatedFees } from "./bridgeHelpers/fee";
+
+export const createTransaction: AccountBridge<Transaction>["createTransaction"] = () => {
+  // log("debug", "[createTransaction] creating base tx");
+  return {
+    family: "internet_computer",
+    amount: new BigNumber(0),
+    fees: getEstimatedFees(),
+    recipient: "",
+    useAllAmount: false,
+  };
+};

package/src/bridge/deviceTransactionConfig.ts

@@ -0,0 +1,53 @@
+import { getCryptoCurrencyById } from "@ledgerhq/cryptoassets/currencies";
+import { log } from "@ledgerhq/logs";
+import { Account, AccountLike } from "@ledgerhq/types-live";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
+import type { CommonDeviceTransactionField } from "@ledgerhq/coin-framework/transaction/common";
+
+import { Transaction, TransactionStatus } from "../types";
+import { methodToString } from "../common-logic/utils";
+
+const currency = getCryptoCurrencyById("internet_computer");
+
+function getDeviceTransactionConfig({
+  transaction,
+}: {
+  account: AccountLike;
+  parentAccount: Account | null | undefined;
+  transaction: Transaction;
+  status: TransactionStatus;
+}): Array<CommonDeviceTransactionField> {
+  const fields: Array<CommonDeviceTransactionField> = [];
+  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/bridge/estimateMaxSpendable.ts

@@ -0,0 +1,19 @@
+import BigNumber from "bignumber.js";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { getEstimatedFees } from "./bridgeHelpers/fee";
+import { Transaction } from "../types";
+
+export const estimateMaxSpendable: AccountBridge<Transaction>["estimateMaxSpendable"] = async ({
+  account,
+  transaction,
+}) => {
+  const balance = account.balance;
+
+  let maxSpendable = balance.minus(transaction?.fees ?? getEstimatedFees());
+
+  if (maxSpendable.isLessThan(0)) {
+    maxSpendable = new BigNumber(0);
+  }
+
+  return maxSpendable;
+};

package/src/bridge/getTransactionStatus.ts

@@ -0,0 +1,75 @@
+import {
+  AmountRequired,
+  InvalidAddress,
+  InvalidAddressBecauseDestinationIsAlsoSource,
+  NotEnoughBalance,
+  RecipientRequired,
+} from "@ledgerhq/errors";
+import BigNumber from "bignumber.js";
+import { AccountBridge } from "@ledgerhq/types-live";
+import { getAddress, validateAddress, validateMemo } from "./bridgeHelpers/addresses";
+import { Transaction, TransactionStatus } from "../types";
+import { InvalidMemoICP } from "../errors";
+
+export const getTransactionStatus: AccountBridge<Transaction>["getTransactionStatus"] = async (
+  account,
+  transaction,
+) => {
+  const errors: TransactionStatus["errors"] = {};
+  const warnings: TransactionStatus["warnings"] = {};
+
+  const { balance } = account;
+  const { address } = getAddress(account);
+  const { recipient, useAllAmount } = transaction;
+  let { amount } = transaction;
+
+  if (!recipient) {
+    errors.recipient = new RecipientRequired();
+  } else if (!(await validateAddress(recipient)).isValid) {
+    errors.recipient = new InvalidAddress("", {
+      currencyName: account.currency.name,
+    });
+  } else if (recipient.toLowerCase() === address.toLowerCase()) {
+    errors.recipient = new InvalidAddressBecauseDestinationIsAlsoSource();
+  }
+
+  if (!(await validateAddress(address)).isValid) {
+    errors.sender = new InvalidAddress("", {
+      currencyName: account.currency.name,
+    });
+  }
+
+  if (!validateMemo(transaction.memo).isValid) {
+    errors.transaction = new InvalidMemoICP();
+  }
+
+  // This is the worst case scenario (the tx won't cost more than this value)
+  const estimatedFees = transaction.fees;
+
+  let totalSpent: BigNumber;
+
+  if (useAllAmount) {
+    totalSpent = account.spendableBalance;
+    amount = totalSpent.minus(estimatedFees);
+    if (amount.lte(0) || totalSpent.gt(balance)) {
+      errors.amount = new NotEnoughBalance();
+    }
+  } else {
+    totalSpent = amount.plus(estimatedFees);
+    if (amount.eq(0)) {
+      errors.amount = new AmountRequired();
+    } else if (totalSpent.gt(account.spendableBalance)) {
+      errors.amount = new NotEnoughBalance();
+    }
+  }
+
+  // log("debug", "[getTransactionStatus] finish fn");
+
+  return {
+    errors,
+    warnings,
+    estimatedFees,
+    amount,
+    totalSpent,
+  };
+};