@ledgerhq/coin-internet_computer/lib-es/bridge/bridgeHelpers/icpRosetta/index.js

Ledger Internet Computer integration

import { constructionInvoke, getICPRosettaNetworkIdentifier } from "../../../api";
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";
export const getUnsignedTransaction = async (transaction, account) => {
    const ops = generateOperations(transaction, account);
    const pubkeys = [
        {
            hex_bytes: account.xpub ?? "",
            curve_type: "secp256k1",
        },
    ];
    const reqOpts = {
        ...getICPRosettaNetworkIdentifier(),
        operations: ops,
        public_keys: pubkeys,
        metadata: {
            memo: parseInt(transaction.memo ?? "0"),
        },
    };
    const { payloads, unsigned_transaction } = await constructionInvoke(reqOpts, "payloads");
    return { unsignedTxn: unsigned_transaction, payloads };
};
export const signICPTransaction = async ({ signerContext, deviceId, unsignedTxn, path, payloads, pubkey, }) => {
    const decodedTxn = 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({
        ...getICPRosettaNetworkIdentifier(),
        signatures: signaturesPayload,
        unsigned_transaction: unsignedTxn,
    }, "combine");
    return { ...result, signedTxn };
};
export const getTxnMetadata = async (signedTxn) => {
    const { transaction_identifier: { hash }, } = await constructionInvoke({ ...getICPRosettaNetworkIdentifier(), signed_transaction: signedTxn }, "hash");
    return { hash };
};
export const getTxnExpirationDate = (_unsignedTxn) => {
    return new Date();
};
export const broadcastTxn = async (signedTxn) => {
    await constructionInvoke({ ...getICPRosettaNetworkIdentifier(), signed_transaction: signedTxn }, "submit");
};
export const deriveAddressFromPubkey = async (pubkey) => {
    const res = await constructionInvoke({
        ...getICPRosettaNetworkIdentifier(),
        public_key: { curve_type: "secp256k1", hex_bytes: pubkey },
    }, "derive");
    return res.account_identifier.address;
};
//# sourceMappingURL=index.js.map