@dfinity/hardware-wallet-cli 0.2.0 → 0.2.1

package/build/index.js

@@ -0,0 +1,401 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * A CLI tool for testing the Ledger hardware wallet integration.
+ */
+const commander_1 = require("commander");
+const identity_1 = require("./src/ledger/identity");
+const nns_1 = require("@dfinity/nns");
+const principal_1 = require("@dfinity/principal");
+const agent_1 = require("@dfinity/agent");
+const chalk_1 = __importDefault(require("chalk"));
+// Add polyfill for `window` for `TransportWebHID` checks to work.
+require("node-window-polyfill/register");
+// Add polyfill for `window.fetch` for agent-js to work.
+// @ts-ignore (no types are available)
+const node_fetch_1 = __importDefault(require("node-fetch"));
+global.fetch = node_fetch_1.default;
+window.fetch = node_fetch_1.default;
+const program = new commander_1.Command();
+const log = console.log;
+const SECONDS_PER_MINUTE = 60;
+const SECONDS_PER_HOUR = 60 * SECONDS_PER_MINUTE;
+const SECONDS_PER_DAY = 24 * SECONDS_PER_HOUR;
+const SECONDS_PER_YEAR = 365 * SECONDS_PER_DAY + 6 * SECONDS_PER_HOUR;
+async function getAgent(identity) {
+    const network = program.opts().network;
+    // Only fetch the rootkey if the network isn't mainnet.
+    const fetchRootKey = new URL(network).host == "ic0.app" ? false : true;
+    const agent = new agent_1.HttpAgent({
+        host: program.opts().network,
+        identity: identity,
+    });
+    if (fetchRootKey) {
+        await agent.fetchRootKey();
+    }
+    return agent;
+}
+/**
+ * Fetches the balance of the main account on the wallet.
+ */
+async function getBalance() {
+    const identity = await identity_1.LedgerIdentity.create();
+    const accountIdentifier = nns_1.AccountIdentifier.fromPrincipal({
+        principal: identity.getPrincipal(),
+    });
+    const ledger = nns_1.LedgerCanister.create({
+        agent: await getAgent(new agent_1.AnonymousIdentity()),
+    });
+    const balance = await ledger.accountBalance({
+        accountIdentifier: accountIdentifier,
+    });
+    ok(`Account ${accountIdentifier.toHex()} has balance ${balance.toE8s()} e8s`);
+}
+/**
+ * Send ICP to another address.
+ *
+ * @param to The account identifier in hex.
+ * @param amount Amount to send in e8s.
+ */
+async function sendICP(to, amount) {
+    const identity = await identity_1.LedgerIdentity.create();
+    const ledger = nns_1.LedgerCanister.create({
+        agent: await getAgent(identity),
+    });
+    const blockHeight = await ledger.transfer({
+        to: to,
+        amount: amount,
+        memo: BigInt(0),
+    });
+    ok(`Transaction completed at block height ${blockHeight}.`);
+}
+/**
+ * Shows the principal and account idenifier on the terminal and on the wallet's screen.
+ */
+async function showInfo(showOnDevice) {
+    const identity = await identity_1.LedgerIdentity.create();
+    const accountIdentifier = nns_1.AccountIdentifier.fromPrincipal({
+        principal: identity.getPrincipal(),
+    });
+    log(chalk_1.default.bold(`Principal: `) + identity.getPrincipal());
+    log(chalk_1.default.bold(`Address (${identity.derivePath}): `) + accountIdentifier.toHex());
+    if (showOnDevice) {
+        log("Displaying the principal and the address on the device...");
+        await identity.showAddressAndPubKeyOnDevice();
+    }
+}
+/**
+ * Stakes a new neuron.
+ *
+ * @param amount Amount to stake in e8s.
+ */
+async function stakeNeuron(stake) {
+    const identity = await identity_1.LedgerIdentity.create();
+    const ledger = nns_1.LedgerCanister.create({
+        agent: await getAgent(identity),
+    });
+    const governance = nns_1.GovernanceCanister.create({
+        agent: await getAgent(new agent_1.AnonymousIdentity()),
+        hardwareWallet: true,
+    });
+    // Flag that an upcoming stake neuron transaction is coming to distinguish
+    // it from a "send ICP" transaction on the device.
+    identity.flagUpcomingStakeNeuron();
+    try {
+        const stakedNeuronId = await governance.stakeNeuron({
+            stake: stake,
+            principal: identity.getPrincipal(),
+            ledgerCanister: ledger,
+        });
+        ok(`Staked neuron with ID: ${stakedNeuronId}`);
+    }
+    catch (error) {
+        if (error instanceof nns_1.InsufficientAmountError) {
+            err(`Cannot stake less than ${error.minimumAmount.toE8s()} e8s`);
+        }
+        else if (error instanceof nns_1.InsufficientFundsError) {
+            err(`Your account has insufficient funds (${error.balance.toE8s()} e8s)`);
+        }
+        else {
+            console.log(error);
+        }
+    }
+}
+async function increaseDissolveDelay(neuronId, years, days, minutes, seconds) {
+    const identity = await identity_1.LedgerIdentity.create();
+    const governance = nns_1.GovernanceCanister.create({
+        agent: await getAgent(identity),
+        hardwareWallet: true,
+    });
+    const additionalDissolveDelaySeconds = years * SECONDS_PER_YEAR +
+        days * SECONDS_PER_DAY +
+        minutes * SECONDS_PER_MINUTE +
+        seconds;
+    await governance.increaseDissolveDelay({
+        neuronId: neuronId,
+        additionalDissolveDelaySeconds: additionalDissolveDelaySeconds,
+    });
+    ok();
+}
+async function disburseNeuron(neuronId, to, amount) {
+    const identity = await identity_1.LedgerIdentity.create();
+    const governance = nns_1.GovernanceCanister.create({
+        agent: await getAgent(identity),
+        hardwareWallet: true,
+    });
+    await governance.disburse({
+        neuronId: BigInt(neuronId),
+        toAccountId: to,
+        amount: amount,
+    });
+    ok();
+}
+async function spawnNeuron(neuronId, controller) {
+    const identity = await identity_1.LedgerIdentity.create();
+    const governance = nns_1.GovernanceCanister.create({
+        agent: await getAgent(identity),
+        hardwareWallet: true,
+    });
+    const spawnedNeuronId = await governance.spawnNeuron({
+        neuronId: BigInt(neuronId),
+        newController: controller,
+    });
+    ok(`Spawned neuron with ID ${spawnedNeuronId}`);
+}
+async function startDissolving(neuronId) {
+    const identity = await identity_1.LedgerIdentity.create();
+    const governance = nns_1.GovernanceCanister.create({
+        agent: await getAgent(identity),
+        hardwareWallet: true,
+    });
+    await governance.startDissolving(neuronId);
+    ok();
+}
+async function stopDissolving(neuronId) {
+    const identity = await identity_1.LedgerIdentity.create();
+    const governance = nns_1.GovernanceCanister.create({
+        agent: await getAgent(identity),
+        hardwareWallet: true,
+    });
+    await governance.stopDissolving(neuronId);
+    ok();
+}
+async function addHotkey(neuronId, principal) {
+    const identity = await identity_1.LedgerIdentity.create();
+    const governance = nns_1.GovernanceCanister.create({
+        agent: await getAgent(identity),
+        hardwareWallet: true,
+    });
+    await governance.addHotkey({
+        neuronId: BigInt(neuronId),
+        principal: principal,
+    });
+    ok();
+}
+async function removeHotkey(neuronId, principal) {
+    const identity = await identity_1.LedgerIdentity.create();
+    const governance = nns_1.GovernanceCanister.create({
+        agent: await getAgent(identity),
+        hardwareWallet: true,
+    });
+    await governance.removeHotkey({
+        neuronId: BigInt(neuronId),
+        principal: principal,
+    });
+    ok();
+}
+async function listNeurons() {
+    const identity = await identity_1.LedgerIdentity.create();
+    const governance = nns_1.GovernanceCanister.create({
+        agent: await getAgent(identity),
+        hardwareWallet: true,
+    });
+    // We filter neurons with no ICP, as they'll be garbage collected by the governance canister.
+    const neurons = await governance.listNeurons({
+        certified: true,
+    });
+    if (neurons.length > 0) {
+        neurons.forEach((n) => {
+            log(`Neuron ID: ${n.neuronId}`);
+        });
+    }
+    else {
+        ok("No neurons found.");
+    }
+}
+const buf2hex = (buffer) => {
+    return [...new Uint8Array(buffer)]
+        .map((x) => x.toString(16).padStart(2, "0"))
+        .join("");
+};
+/**
+ * Fetches the balance of the main account on the wallet.
+ */
+async function claimNeurons() {
+    const identity = await identity_1.LedgerIdentity.create();
+    const bufferKey = identity.getPublicKey();
+    const hexPubKey = buf2hex(bufferKey.toRaw());
+    const isHex = hexPubKey.match("^[0-9a-fA-F]+$");
+    if (!isHex) {
+        throw new Error(`${hexPubKey} is not a hex string.`);
+    }
+    if (hexPubKey.length < 130 || hexPubKey.length > 150) {
+        throw new Error(`The key must be >= 130 characters and <= 150 characters.`);
+    }
+    const governance = await nns_1.GenesisTokenCanister.create({
+        agent: await getAgent(identity),
+    });
+    const claimedNeuronIds = await governance.claimNeurons({
+        hexPubKey: hexPubKey,
+    });
+    ok(`Successfully claimed the following neurons: ${claimedNeuronIds}`);
+}
+/**
+ * Runs a function with a try/catch block.
+ */
+async function run(f) {
+    try {
+        await f();
+    }
+    catch (error) {
+        err(error);
+    }
+}
+function ok(message) {
+    if (message) {
+        log(`${chalk_1.default.green(chalk_1.default.bold("OK"))}: ${message}`);
+    }
+    else {
+        log(`${chalk_1.default.green(chalk_1.default.bold("OK"))}`);
+    }
+}
+function err(error) {
+    const message = error instanceof nns_1.GovernanceError
+        ? error.detail.error_message
+        : error instanceof Error
+            ? error.message
+            : error;
+    log(`${chalk_1.default.bold(chalk_1.default.red("Error:"))} ${message}`);
+}
+function tryParseInt(value) {
+    const parsedValue = parseInt(value, 10);
+    if (isNaN(parsedValue)) {
+        throw new commander_1.InvalidArgumentError("Not a number.");
+    }
+    return parsedValue;
+}
+function tryParseBigInt(value) {
+    try {
+        return BigInt(value);
+    }
+    catch (err) {
+        throw new commander_1.InvalidArgumentError(err.toString());
+    }
+}
+function tryParsePrincipal(value) {
+    try {
+        return principal_1.Principal.fromText(value);
+    }
+    catch (err) {
+        throw new commander_1.InvalidArgumentError(err.toString());
+    }
+}
+function tryParseE8s(e8s) {
+    try {
+        return nns_1.ICP.fromE8s(tryParseBigInt(e8s));
+    }
+    catch (err) {
+        throw new commander_1.InvalidArgumentError(err.toString());
+    }
+}
+function tryParseAccountIdentifier(accountIdentifier) {
+    try {
+        return nns_1.AccountIdentifier.fromHex(accountIdentifier);
+    }
+    catch (err) {
+        throw new commander_1.InvalidArgumentError(err.toString());
+    }
+}
+async function main() {
+    const neuron = new commander_1.Command("neuron")
+        .description("Commands for managing neurons.")
+        .showSuggestionAfterError()
+        .addCommand(new commander_1.Command("stake")
+        .requiredOption("--amount <amount>", "Amount to stake in e8s.", tryParseE8s)
+        .action((args) => run(() => stakeNeuron(args.amount))))
+        .addCommand(new commander_1.Command("increase-dissolve-delay")
+        .requiredOption("--neuron-id <neuron-id>", "Neuron ID", tryParseBigInt)
+        .option("--years <years>", "Number of years", tryParseInt)
+        .option("--days <days>", "Number of days", tryParseInt)
+        .option("--minutes <minutes>", "Number of minutes", tryParseInt)
+        .option("--seconds <seconds>", "Number of seconds", tryParseInt)
+        .action((args) => run(() => increaseDissolveDelay(args.neuronId, args.years || 0, args.days || 0, args.minutes || 0, args.seconds || 0))))
+        .addCommand(new commander_1.Command("disburse")
+        .requiredOption("--neuron-id <neuron-id>", "Neuron ID", tryParseBigInt)
+        .option("--to <account-identifier>")
+        .option("--amount <amount>", "Amount to disburse (empty to disburse all)", tryParseBigInt)
+        .action((args) => {
+        run(() => disburseNeuron(args.neuronId, args.to, args.amount));
+    }))
+        .addCommand(new commander_1.Command("spawn")
+        .requiredOption("--neuron-id <neuron-id>", "Neuron ID", tryParseBigInt)
+        .option("--controller <new-controller>", "Controller", tryParsePrincipal)
+        .action((args) => {
+        run(() => spawnNeuron(args.neuronId, args.controller));
+    }))
+        .addCommand(new commander_1.Command("start-dissolving")
+        .requiredOption("--neuron-id <neuron-id>", "Neuron ID", tryParseBigInt)
+        .action((args) => {
+        run(() => startDissolving(args.neuronId));
+    }))
+        .addCommand(new commander_1.Command("stop-dissolving")
+        .requiredOption("--neuron-id <neuron-id>", "Neuron ID", tryParseBigInt)
+        .action((args) => {
+        run(() => stopDissolving(args.neuronId));
+    }))
+        .addCommand(new commander_1.Command("list").action(() => run(listNeurons)))
+        .addCommand(new commander_1.Command("add-hotkey")
+        .requiredOption("--neuron-id <neuron-id>", "Neuron ID", tryParseBigInt)
+        .requiredOption("--principal <principal>", "Principal", tryParsePrincipal)
+        .action((args) => run(() => addHotkey(args.neuronId, args.principal))))
+        .addCommand(new commander_1.Command("remove-hotkey")
+        .requiredOption("--neuron-id <neuron-id>", "Neuron ID", tryParseBigInt)
+        .requiredOption("--principal <principal>", "Principal", tryParsePrincipal)
+        .action((args) => run(() => removeHotkey(args.neuronId, args.principal))))
+        .addCommand(new commander_1.Command("claim")
+        .description("Claim the caller's GTC neurons.")
+        .action((args) => run(() => claimNeurons())));
+    const icp = new commander_1.Command("icp")
+        .description("Commands for managing ICP.")
+        .showSuggestionAfterError()
+        .addCommand(new commander_1.Command("balance")
+        .description("Fetch current balance.")
+        .action(() => {
+        run(getBalance);
+    }))
+        .addCommand(new commander_1.Command("transfer")
+        .requiredOption("--to <account-identifier>", "Account identifier to transfer to.", tryParseAccountIdentifier)
+        .requiredOption("--amount <amount>", "Amount to transfer in e8s.", tryParseE8s)
+        .action((args) => run(() => sendICP(args.to, args.amount))));
+    program
+        .description("A CLI for the Ledger hardware wallet.")
+        .enablePositionalOptions()
+        .showSuggestionAfterError()
+        .addOption(new commander_1.Option("--network <network>", "The IC network to talk to.")
+        .default("https://ic0.app")
+        .env("IC_NETWORK"))
+        .addCommand(new commander_1.Command("info")
+        .option("-n --no-show-on-device")
+        .description("Show the wallet's principal, address, and balance.")
+        .action((args) => {
+        run(() => showInfo(args.showOnDevice));
+    }))
+        .addCommand(icp)
+        .addCommand(neuron);
+    await program.parseAsync(process.argv);
+}
+main();

package/build/src/ledger/identity.js

@@ -0,0 +1,218 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LedgerIdentity = void 0;
+const agent_1 = require("@dfinity/agent");
+const principal_1 = require("@dfinity/principal");
+const ledger_icp_1 = __importStar(require("@zondax/ledger-icp"));
+const secp256k1_1 = require("./secp256k1");
+// @ts-ignore (no types are available)
+const hw_transport_webhid_1 = __importDefault(require("@ledgerhq/hw-transport-webhid"));
+const hw_transport_node_hid_noevents_1 = __importDefault(require("@ledgerhq/hw-transport-node-hid-noevents"));
+// Add polyfill for `window.fetch` for agent-js to work.
+// @ts-ignore (no types are available)
+const node_fetch_1 = __importDefault(require("node-fetch"));
+global.fetch = node_fetch_1.default;
+/**
+ * Convert the HttpAgentRequest body into cbor which can be signed by the Ledger Hardware Wallet.
+ * @param request - body of the HttpAgentRequest
+ */
+function _prepareCborForLedger(request) {
+    return agent_1.Cbor.encode({ content: request });
+}
+/**
+ * A Hardware Ledger Internet Computer Agent identity.
+ */
+class LedgerIdentity extends agent_1.SignIdentity {
+    constructor(derivePath, _publicKey) {
+        super();
+        this.derivePath = derivePath;
+        this._publicKey = _publicKey;
+        // A flag to signal that the next transaction to be signed will be
+        // a "stake neuron" transaction.
+        this._neuronStakeFlag = false;
+    }
+    /**
+     * Create a LedgerIdentity using the Web USB transport.
+     * @param derivePath The derivation path.
+     */
+    static async create(derivePath = `m/44'/223'/0'/0/0`) {
+        const [app, transport] = await this._connect();
+        try {
+            const publicKey = await this._fetchPublicKeyFromDevice(app, derivePath);
+            return new this(derivePath, publicKey);
+        }
+        finally {
+            // Always close the transport.
+            transport.close();
+        }
+    }
+    /**
+     * Connect to a ledger hardware wallet.
+     */
+    static async _connect() {
+        async function getTransport() {
+            if (await hw_transport_webhid_1.default.isSupported()) {
+                // We're in a web browser.
+                return hw_transport_webhid_1.default.create();
+            }
+            else if (await hw_transport_node_hid_noevents_1.default.isSupported()) {
+                // Maybe we're in a CLI.
+                return hw_transport_node_hid_noevents_1.default.create();
+            }
+            else {
+                // Unknown environment.
+                throw Error();
+            }
+        }
+        try {
+            const transport = await getTransport();
+            const app = new ledger_icp_1.default(transport);
+            return [app, transport];
+        }
+        catch (err) {
+            // @ts-ignore
+            if (err.id && err.id == "NoDeviceFound") {
+                throw "No Ledger device found. Is the wallet connected and unlocked?";
+            }
+            else if (
+            // @ts-ignore
+            err.message &&
+                // @ts-ignore
+                err.message.includes("cannot open device with path")) {
+                throw "Cannot connect to Ledger device. Please close all other wallet applications (e.g. Ledger Live) and try again.";
+            }
+            else {
+                // Unsupported browser. Data on browser compatibility is taken from https://caniuse.com/webhid
+                throw `Cannot connect to Ledger Wallet. Either you have other wallet applications open (e.g. Ledger Live), or your browser doesn't support WebHID, which is necessary to communicate with your Ledger hardware wallet.\n\nSupported browsers:\n* Chrome (Desktop) v89+\n* Edge v89+\n* Opera v76+\n\nError: ${err}`;
+            }
+        }
+    }
+    static async _fetchPublicKeyFromDevice(app, derivePath) {
+        const resp = await app.getAddressAndPubKey(derivePath);
+        // @ts-ignore
+        if (resp.returnCode == 28161) {
+            throw "Please open the Internet Computer app on your wallet and try again.";
+        }
+        else if (resp.returnCode == ledger_icp_1.LedgerError.TransactionRejected) {
+            throw "Ledger Wallet is locked. Unlock it and try again.";
+            // @ts-ignore
+        }
+        else if (resp.returnCode == 65535) {
+            throw "Unable to fetch the public key. Please try again.";
+        }
+        // This type doesn't have the right fields in it, so we have to manually type it.
+        const principal = resp
+            .principalText;
+        const publicKey = secp256k1_1.Secp256k1PublicKey.fromRaw(new Uint8Array(resp.publicKey));
+        if (principal !==
+            principal_1.Principal.selfAuthenticating(new Uint8Array(publicKey.toDer())).toText()) {
+            throw new Error("Principal returned by device does not match public key.");
+        }
+        return publicKey;
+    }
+    /**
+     * Required by Ledger.com that the user should be able to press a Button in UI
+     * and verify the address/pubkey are the same as on the device screen.
+     */
+    async showAddressAndPubKeyOnDevice() {
+        this._executeWithApp(async (app) => {
+            await app.showAddressAndPubKey(this.derivePath);
+        });
+    }
+    /**
+     * @returns The verion of the `Internet Computer' app installed on the Ledger device.
+     */
+    async getVersion() {
+        return this._executeWithApp(async (app) => {
+            const res = await app.getVersion();
+            return {
+                major: res.major,
+                minor: res.minor,
+                patch: res.patch,
+            };
+        });
+    }
+    getPublicKey() {
+        return this._publicKey;
+    }
+    async sign(blob) {
+        return await this._executeWithApp(async (app) => {
+            const resp = await app.sign(this.derivePath, Buffer.from(blob), this._neuronStakeFlag ? 1 : 0);
+            // Remove the "neuron stake" flag, since we already signed the transaction.
+            this._neuronStakeFlag = false;
+            const signatureRS = resp.signatureRS;
+            if (!signatureRS) {
+                throw new Error(`A ledger error happened during signature:\n` +
+                    `Code: ${resp.returnCode}\n` +
+                    `Message: ${JSON.stringify(resp.errorMessage)}\n`);
+            }
+            if (signatureRS?.byteLength !== 64) {
+                throw new Error(`Signature must be 64 bytes long (is ${signatureRS.length})`);
+            }
+            return bufferToArrayBuffer(signatureRS);
+        });
+    }
+    /**
+     * Signals that the upcoming transaction to be signed will be a "stake neuron" transaction.
+     */
+    flagUpcomingStakeNeuron() {
+        this._neuronStakeFlag = true;
+    }
+    async transformRequest(request) {
+        const { body, ...fields } = request;
+        const signature = await this.sign(_prepareCborForLedger(body));
+        return {
+            ...fields,
+            body: {
+                content: body,
+                sender_pubkey: this._publicKey.toDer(),
+                sender_sig: signature,
+            },
+        };
+    }
+    async _executeWithApp(func) {
+        const [app, transport] = await LedgerIdentity._connect();
+        try {
+            // Verify that the public key of the device matches the public key of this identity.
+            const devicePublicKey = await LedgerIdentity._fetchPublicKeyFromDevice(app, this.derivePath);
+            if (JSON.stringify(devicePublicKey) !== JSON.stringify(this._publicKey)) {
+                throw new Error("Found unexpected public key. Are you sure you're using the right wallet?");
+            }
+            // Run the provided function.
+            return await func(app);
+        }
+        finally {
+            transport.close();
+        }
+    }
+}
+exports.LedgerIdentity = LedgerIdentity;
+function bufferToArrayBuffer(buffer) {
+    return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+}

package/build/src/ledger/secp256k1.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Secp256k1PublicKey = void 0;
+function equals(b1, b2) {
+    if (b1.byteLength !== b2.byteLength) {
+        return false;
+    }
+    const u1 = new Uint8Array(b1);
+    const u2 = new Uint8Array(b2);
+    for (let i = 0; i < u1.length; i++) {
+        if (u1[i] !== u2[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+// This implementation is adjusted from the Ed25519PublicKey.
+// The RAW_KEY_LENGTH and DER_PREFIX are modified accordingly
+class Secp256k1PublicKey {
+    // `fromRaw` and `fromDer` should be used for instantiation, not this constructor.
+    constructor(key) {
+        this.rawKey = key;
+        this.derKey = Secp256k1PublicKey.derEncode(key);
+    }
+    static fromRaw(rawKey) {
+        return new Secp256k1PublicKey(rawKey);
+    }
+    static fromDer(derKey) {
+        return new Secp256k1PublicKey(this.derDecode(derKey));
+    }
+    static derEncode(publicKey) {
+        if (publicKey.byteLength !== Secp256k1PublicKey.RAW_KEY_LENGTH) {
+            const bl = publicKey.byteLength;
+            throw new TypeError(`secp256k1 public key must be ${Secp256k1PublicKey.RAW_KEY_LENGTH} bytes long (is ${bl})`);
+        }
+        const derPublicKey = Uint8Array.from([
+            ...Secp256k1PublicKey.DER_PREFIX,
+            ...new Uint8Array(publicKey),
+        ]);
+        return derPublicKey.buffer;
+    }
+    static derDecode(key) {
+        const expectedLength = Secp256k1PublicKey.DER_PREFIX.length + Secp256k1PublicKey.RAW_KEY_LENGTH;
+        if (key.byteLength !== expectedLength) {
+            const bl = key.byteLength;
+            throw new TypeError(`secp256k1 DER-encoded public key must be ${expectedLength} bytes long (is ${bl})`);
+        }
+        const rawKey = key.slice(0, Secp256k1PublicKey.DER_PREFIX.length);
+        if (!equals(this.derEncode(rawKey), key)) {
+            throw new TypeError("secp256k1 DER-encoded public key is invalid. A valid secp256k1 DER-encoded public key " +
+                `must have the following prefix: ${Secp256k1PublicKey.DER_PREFIX}`);
+        }
+        return rawKey;
+    }
+    toDer() {
+        return this.derKey;
+    }
+    toRaw() {
+        return this.rawKey;
+    }
+}
+exports.Secp256k1PublicKey = Secp256k1PublicKey;
+// The length of secp256k1 public keys is always 65 bytes.
+Secp256k1PublicKey.RAW_KEY_LENGTH = 65;
+// Adding this prefix to a raw public key is sufficient to DER-encode it.
+// prettier-ignore
+Secp256k1PublicKey.DER_PREFIX = Uint8Array.from([
+    0x30, 0x56,
+    0x30, 0x10,
+    0x06, 0x07, 0x2a, 0x86, 0x48, 0xce, 0x3d, 0x02, 0x01,
+    0x06, 0x05, 0x2b, 0x81, 0x04, 0x00, 0x0a,
+    0x03, 0x42,
+    0x00, // no padding
+]);

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@dfinity/hardware-wallet-cli",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "A CLI to interact with the Internet Computer App on Ledger Nano S/X devices.",
   "main": "./build/index.js",
   "scripts": {
     "format": "prettier --write .",
     "test": "echo \"Error: no test specified\" && exit 1",
     "build": "tsc --build",
+    "prepack": "npm run build",
     "clean": "tsc --build --clean",
     "refresh": "rm -rf ./node_modules ./package-lock.json && npm install",
     "execute": "ts-node ./index.ts"