@ledgerhq/coin-internet_computer/lib-es/api/api.js

Ledger Internet Computer integration

import { log } from "@ledgerhq/logs";
import { ledgerIdlFactory, indexIdlFactory, getCanisterIdlFunc, Principal, encodeCanisterIdlFunc, decodeCanisterIdlFunc, } from "@zondax/ledger-live-icp";
import { Certificate, Cbor, getAgent, lookupResultToBuffer } from "@zondax/ledger-live-icp/agent";
import { fromNullable } from "@zondax/ledger-live-icp/utils";
import BigNumber from "bignumber.js";
import invariant from "invariant";
import { FETCH_TXNS_LIMIT, MAINNET_INDEX_CANISTER_ID, MAINNET_LEDGER_CANISTER_ID, ICP_NETWORK_URL, } from "../consts";
function toArrayBuffer(view) {
    if (view instanceof ArrayBuffer) {
        return view;
    }
    const copy = new Uint8Array(view.byteLength);
    copy.set(view);
    return copy.buffer;
}
function requestIdFromHex(hex) {
    const bytes = Buffer.from(hex, "hex");
    const copy = new Uint8Array(bytes);
    return copy.buffer;
}
function throwIfLedgerTransferReplyIsErr(replyBuf) {
    const transferIdlFunc = getCanisterIdlFunc(ledgerIdlFactory, "transfer");
    const decoded = decodeCanisterIdlFunc(transferIdlFunc, replyBuf);
    const out = decoded[0];
    if (out.Err) {
        const message = JSON.stringify(out.Err, (_, v) => (typeof v === "bigint" ? v.toString() : v));
        throw new Error(message);
    }
}
async function fetchRootKey() {
    const res = await fetch(`${ICP_NETWORK_URL}/api/v2/status`);
    if (res.status !== 200) {
        throw new Error(`Failed to fetch status: ${await res.text()}`);
    }
    const status = Cbor.decode(await res.arrayBuffer());
    invariant(status.root_key, "[ICP](fetchRootKey) Missing root_key in status response");
    return toArrayBuffer(status.root_key);
}
export const fetchBlockHeight = async () => {
    const canisterId = Principal.fromText(MAINNET_LEDGER_CANISTER_ID);
    const queryBlocksRawRequest = {
        start: BigInt(0),
        length: BigInt(1),
    };
    const queryBlocksIdlFunc = getCanisterIdlFunc(ledgerIdlFactory, "query_blocks");
    const queryBlocksargs = encodeCanisterIdlFunc(queryBlocksIdlFunc, [queryBlocksRawRequest]);
    const agent = await getAgent(ICP_NETWORK_URL);
    const blockHeightRes = await agent.query(canisterId, {
        arg: queryBlocksargs,
        methodName: "query_blocks",
    });
    invariant(blockHeightRes.status === "replied", "[ICP](fetchBlockHeight) Query failed");
    const decodedIdl = decodeCanisterIdlFunc(queryBlocksIdlFunc, blockHeightRes.reply.arg);
    const decoded = fromNullable(decodedIdl);
    invariant(decoded, "[ICP](fetchBlockHeight) Decoding failed");
    return BigNumber(decoded.chain_length.toString());
};
export const broadcastTxn = async (payload, canisterId, type) => {
    log("debug", `[ICP] Broadcasting ${type} to ${canisterId}, body: ${payload.toString("hex")}`);
    const res = await fetch(`${ICP_NETWORK_URL}/api/v3/canister/${canisterId}/${type}`, {
        body: payload,
        method: "POST",
        headers: {
            "Content-Type": "application/cbor",
        },
    });
    if (res.status === 200) {
        return new Uint8Array(await res.arrayBuffer());
    }
    throw new Error(`Failed to broadcast transaction: ${await res.text()}`);
};
export const ensureTransferCallAccepted = async (syncCallResponse, transferRequestIdHex) => {
    const requestId = requestIdFromHex(transferRequestIdHex);
    const canisterId = Principal.fromText(MAINNET_LEDGER_CANISTER_ID);
    const top = Cbor.decode(toArrayBuffer(syncCallResponse));
    invariant(top.status === "replied" && top.certificate, "[ICP](ensureTransferCallAccepted) Decoding failed");
    const rootKey = await fetchRootKey();
    const cert = await Certificate.create({
        certificate: toArrayBuffer(top.certificate),
        rootKey,
        canisterId,
        maxAgeInMinutes: 100,
    });
    const replyBuf = lookupResultToBuffer(cert.lookup(["request_status", requestId, "reply"]));
    invariant(replyBuf, "[ICP](ensureTransferCallAccepted) Reply status not found");
    throwIfLedgerTransferReplyIsErr(replyBuf);
};
export const fetchBalance = async (address) => {
    const agent = await getAgent(ICP_NETWORK_URL);
    const indexCanister = Principal.fromText(MAINNET_INDEX_CANISTER_ID);
    const getBalanceIdlFunc = getCanisterIdlFunc(indexIdlFactory, "get_account_identifier_balance");
    const getBalanceArgs = encodeCanisterIdlFunc(getBalanceIdlFunc, [address]);
    const balanceRes = await agent.query(indexCanister, {
        arg: getBalanceArgs,
        methodName: "get_account_identifier_balance",
    });
    if (balanceRes.status !== "replied") {
        log("debug", `[ICP](fetchBalance) Query failed: ${balanceRes.status}`);
        return BigNumber(0);
    }
    const decodedBalance = decodeCanisterIdlFunc(getBalanceIdlFunc, balanceRes.reply.arg);
    const balance = fromNullable(decodedBalance);
    if (!balance) {
        return BigNumber(0);
    }
    return BigNumber(balance.toString());
};
export const fetchTxns = async (address, startBlockHeight, stopBlockHeight = BigInt(0)) => {
    if (startBlockHeight <= stopBlockHeight) {
        return [];
    }
    const agent = await getAgent(ICP_NETWORK_URL);
    const canisterId = Principal.fromText(MAINNET_INDEX_CANISTER_ID);
    const transactionsRawRequest = {
        account_identifier: address,
        start: [startBlockHeight],
        max_results: BigInt(FETCH_TXNS_LIMIT),
    };
    const getTransactionsIdlFunc = getCanisterIdlFunc(indexIdlFactory, "get_account_identifier_transactions");
    const getTransactionsArgs = encodeCanisterIdlFunc(getTransactionsIdlFunc, [
        transactionsRawRequest,
    ]);
    const transactionsRes = await agent.query(canisterId, {
        arg: getTransactionsArgs,
        methodName: "get_account_identifier_transactions",
    });
    invariant(transactionsRes.status === "replied", "[ICP](fetchTxns) Query failed");
    const decodedTransactions = decodeCanisterIdlFunc(getTransactionsIdlFunc, transactionsRes.reply.arg);
    const response = fromNullable(decodedTransactions);
    invariant(response, "[ICP](fetchTxns) Decoding failed");
    if (response.Ok.transactions.length === 0) {
        return [];
    }
    const nextTxns = await fetchTxns(address, response.Ok.transactions.at(-1)?.id ?? BigInt(0), stopBlockHeight);
    return [...response.Ok.transactions, ...nextTxns];
};
//# sourceMappingURL=api.js.map