@ledgerhq/coin-internet_computer 1.9.0-nightly.8 → 1.9.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

@@ -1,40 +1,15 @@
 import { AccountBridge } from "@ledgerhq/types-live";
-import { broadcastTxn } from "../api";
+import { broadcastTxn } from "./bridgeHelpers/icpRosetta";
 import { Transaction } from "../types";
-import { log } from "@ledgerhq/logs";
-import invariant from "invariant";
-import { MAINNET_LEDGER_CANISTER_ID } from "../consts";
 
-// Interface to structure raw data for broadcasting transactions
-interface BroadcastRawData {
-  encodedSignedCallBlob: string;
-}
-
-// Type guard to validate rawData shape
-function isBroadcastRawData(data: unknown): data is BroadcastRawData {
-  return (
-    typeof data === "object" &&
-    data !== null &&
-    "encodedSignedCallBlob" in data &&
-    typeof (data as any).encodedSignedCallBlob === "string"
-  );
-}
-
-// Main broadcast function for handling Internet Computer transactions
 export const broadcast: AccountBridge<Transaction>["broadcast"] = async ({
-  signedOperation: { operation, rawData },
+  signedOperation: { signature, operation },
 }) => {
-  log("debug", "[broadcast] Internet Computer transaction broadcast initiated");
+  // log("debug", "[broadcast] start fn");
 
-  // Validate rawData with type guard
-  invariant(isBroadcastRawData(rawData), "[ICP](broadcast) Invalid rawData format");
-  invariant(operation.extra, "[ICP](broadcast) Missing operation extra");
+  await broadcastTxn(signature);
 
-  await broadcastTxn(
-    Buffer.from(rawData.encodedSignedCallBlob, "hex"),
-    MAINNET_LEDGER_CANISTER_ID,
-    "call",
-  );
+  const result = { ...operation };
 
-  return operation;
+  return result;
 };

package/src/bridge/getTransactionStatus.ts

@@ -7,8 +7,7 @@ import {
 } from "@ledgerhq/errors";
 import BigNumber from "bignumber.js";
 import { AccountBridge } from "@ledgerhq/types-live";
-import { getAddress } from "./bridgeHelpers/addresses";
-import { validateAddress, validateMemo } from "@zondax/ledger-live-icp/utils";
+import { getAddress, validateAddress, validateMemo } from "./bridgeHelpers/addresses";
 import { Transaction, TransactionStatus } from "../types";
 import { InvalidMemoICP } from "../errors";
 

package/src/bridge/prepareTransaction.ts

@@ -1,7 +1,6 @@
 import { AccountBridge } from "@ledgerhq/types-live";
 import { Transaction } from "../types";
-import { getAddress } from "./bridgeHelpers/addresses";
-import { validateAddress } from "@zondax/ledger-live-icp";
+import { getAddress, validateAddress } from "./bridgeHelpers/addresses";
 
 export const prepareTransaction: AccountBridge<Transaction>["prepareTransaction"] = async (
   account,

package/src/bridge/signOperation.ts

@@ -1,103 +1,53 @@
 import { Observable } from "rxjs";
-import { Account, AccountBridge, DeviceId } from "@ledgerhq/types-live";
+import { Account, AccountBridge } from "@ledgerhq/types-live";
 import { getAddress } from "./bridgeHelpers/addresses";
 import {
-  UnsignedTransaction,
-  createUnsignedSendTransaction,
-  hashTransaction,
-  pubkeyToDer,
-} from "@zondax/ledger-live-icp/utils";
-import { Cbor } from "@zondax/ledger-live-icp/agent";
+  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";
-import { log } from "@ledgerhq/logs";
-import invariant from "invariant";
-
-const signICPTransaction = async (
-  unsignedTxn: UnsignedTransaction,
-  derivationPath: string,
-  signerContext: SignerContext<ICPSigner>,
-  account: Account,
-  deviceId: DeviceId,
-) => {
-  const blob = Cbor.encode({ content: unsignedTxn });
-  log("debug", "[signICPTransaction] blob", Buffer.from(blob).toString("hex"));
-  const signatures = await signerContext(deviceId, signer =>
-    signer.sign(derivationPath, Buffer.from(blob)),
-  );
-
-  invariant(signatures.signatureRS, "[ICP](signICPTransaction) Signature not found");
-  invariant(account.xpub, "[ICP](signICPTransaction) Account xpub is required");
-  return {
-    signature: Buffer.from(signatures.signatureRS).toString("hex"),
-    callBody: {
-      content: unsignedTxn,
-      sender_pubkey: pubkeyToDer(account.xpub),
-      sender_sig: signatures.signatureRS,
-    },
-  };
-};
 
 export const buildSignOperation =
-  (signerContext: SignerContext<ICPSigner>): AccountBridge<Transaction>["signOperation"] =>
+  (signerContext: SignerContext<ICPSigner>): AccountBridge<Transaction, Account>["signOperation"] =>
   ({ account, transaction, deviceId }) =>
     new Observable(o => {
       async function main() {
-        log("debug", "[signOperation] icp start fn");
-        log("debug", "[signOperation] transaction", transaction);
-
         const { xpub } = account;
-        invariant(xpub, "[ICP](signOperation) Account xpub is required");
-
         const { derivationPath } = getAddress(account);
-
-        const { unsignedTransaction, transferRawRequest } = createUnsignedSendTransaction(
-          transaction,
-          xpub,
-        );
+        const { unsignedTxn, payloads } = await getUnsignedTransaction(transaction, account);
 
         o.next({
           type: "device-signature-requested",
         });
 
-        let signature: string = "";
-        let encodedSignedCallBlob: string = "";
-        const res = await signICPTransaction(
-          unsignedTransaction,
-          getPath(derivationPath),
+        const { signedTxn } = await signICPTransaction({
           signerContext,
-          account,
           deviceId,
-        );
-        signature = res.signature;
-        encodedSignedCallBlob = Buffer.from(Cbor.encode(res.callBody)).toString("hex");
-        invariant(signature, "[ICP](signOperation) Signature not found");
+          unsignedTxn,
+          path: getPath(derivationPath),
+          payloads,
+          pubkey: xpub ?? "",
+        });
 
         o.next({
           type: "device-signature-granted",
         });
 
-        const hash = hashTransaction({
-          from: account.freshAddress,
-          to: transaction.recipient,
-          amount: transferRawRequest.amount.e8s,
-          fee: transferRawRequest.fee.e8s,
-          memo: transferRawRequest.memo,
-          created_at_time: transferRawRequest.created_at_time[0]["timestamp_nanos"],
-        });
-
+        const { hash } = await getTxnMetadata(signedTxn);
         const operation = await buildOptimisticOperation(account, transaction, hash);
+
         o.next({
           type: "signed",
           signedOperation: {
             operation,
-            signature,
-            rawData: {
-              encodedSignedCallBlob,
-            },
+            signature: signedTxn,
+            expirationDate: getTxnExpirationDate(unsignedTxn),
           },
         });
       }

package/src/consts.ts

@@ -9,13 +9,3 @@ export const ICP_FEES = 1e4;
 
 // Max Memo value on ICP network
 export const MAX_MEMO_VALUE = Number.MAX_SAFE_INTEGER;
-
-// API limits
-export const FETCH_TXNS_LIMIT = 100;
-
-export {
-  MAINNET_GOVERNANCE_CANISTER_ID,
-  MAINNET_LEDGER_CANISTER_ID,
-  MAINNET_INDEX_CANISTER_ID,
-  ICP_NETWORK_URL,
-} from "@zondax/ledger-live-icp/neurons";

package/src/hw-signMessage.ts

@@ -1,5 +1,6 @@
 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";
@@ -18,7 +19,11 @@ export const signMessage =
     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));
+      const r = await signer.sign(
+        account.freshAddressPath,
+        getBufferFromString(message),
+        ICP_SEND_TXN_TYPE,
+      );
       return { r };
     });