@bitcoinerlab/descriptors 0.2.0

package/dist/index.js

@@ -0,0 +1,53 @@
+"use strict";
+// Copyright (c) 2023 Jose-Luis Landabaso - https://bitcoinerlab.com
+// Distributed under the MIT software license
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ledger = exports.scriptExpressions = exports.keyExpressionLedger = exports.keyExpressionBIP32 = exports.finalizePsbt = exports.signers = exports.checksum = exports.DescriptorsFactory = void 0;
+var types_1 = require("./types");
+var descriptors_1 = require("./descriptors");
+Object.defineProperty(exports, "DescriptorsFactory", { enumerable: true, get: function () { return descriptors_1.DescriptorsFactory; } });
+var checksum_1 = require("./checksum");
+Object.defineProperty(exports, "checksum", { enumerable: true, get: function () { return checksum_1.DescriptorChecksum; } });
+const signers = __importStar(require("./signers"));
+exports.signers = signers;
+function finalizePsbt({ psbt, descriptors, validate = true }) {
+    descriptors.forEach((descriptor, inputIndex) => descriptor.finalizePsbtInput({ index: inputIndex, psbt, validate }));
+}
+exports.finalizePsbt = finalizePsbt;
+var keyExpressions_1 = require("./keyExpressions");
+Object.defineProperty(exports, "keyExpressionBIP32", { enumerable: true, get: function () { return keyExpressions_1.keyExpressionBIP32; } });
+Object.defineProperty(exports, "keyExpressionLedger", { enumerable: true, get: function () { return keyExpressions_1.keyExpressionLedger; } });
+const scriptExpressions = __importStar(require("./scriptExpressions"));
+exports.scriptExpressions = scriptExpressions;
+const ledger_1 = require("@bitcoinerlab/ledger");
+const ledger_2 = require("./ledger");
+exports.ledger = {
+    getLedgerMasterFingerPrint: ledger_2.getLedgerMasterFingerPrint,
+    getLedgerXpub: ledger_2.getLedgerXpub,
+    registerLedgerWallet: ledger_2.registerLedgerWallet,
+    assertLedgerApp: ledger_2.assertLedgerApp,
+    AppClient: ledger_1.AppClient
+};

package/dist/keyExpressions.d.ts

@@ -0,0 +1,29 @@
+import { Network } from 'bitcoinjs-lib';
+import type { ECPairAPI } from 'ecpair';
+import type { BIP32API, BIP32Interface } from 'bip32';
+import type { KeyInfo } from './types';
+import { LedgerState } from './ledger';
+import type { AppClient } from '@bitcoinerlab/ledger';
+export declare function parseKeyExpression({ keyExpression, isSegwit, ECPair, BIP32, network }: {
+    keyExpression: string;
+    network?: Network;
+    isSegwit?: boolean;
+    ECPair: ECPairAPI;
+    BIP32: BIP32API;
+}): KeyInfo;
+export declare function keyExpressionLedger({ ledgerClient, ledgerState, originPath, keyPath, change, index }: {
+    ledgerClient: AppClient;
+    ledgerState: LedgerState;
+    originPath: string;
+    change?: number | undefined;
+    index?: number | undefined | '*';
+    keyPath?: string | undefined;
+}): Promise<string>;
+export declare function keyExpressionBIP32({ masterNode, originPath, keyPath, change, index, isPublic }: {
+    masterNode: BIP32Interface;
+    originPath: string;
+    change?: number | undefined;
+    index?: number | undefined | '*';
+    keyPath?: string | undefined;
+    isPublic?: boolean;
+}): string;

package/dist/keyExpressions.js

@@ -0,0 +1,196 @@
+"use strict";
+// Copyright (c) 2023 Jose-Luis Landabaso - https://bitcoinerlab.com
+// Distributed under the MIT software license
+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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keyExpressionBIP32 = exports.keyExpressionLedger = exports.parseKeyExpression = void 0;
+const bitcoinjs_lib_1 = require("bitcoinjs-lib");
+const ledger_1 = require("./ledger");
+const RE = __importStar(require("./re"));
+const derivePath = (node, path) => {
+    if (typeof path !== 'string') {
+        throw new Error(`Error: invalid derivation path ${path}`);
+    }
+    const parsedPath = path.replaceAll('H', "'").replaceAll('h', "'").slice(1);
+    const splitPath = parsedPath.split('/');
+    for (const element of splitPath) {
+        const unhardened = element.endsWith("'") ? element.slice(0, -1) : element;
+        if (!Number.isInteger(Number(unhardened)) ||
+            Number(unhardened) >= 0x80000000)
+            throw new Error(`Error: BIP 32 path element overflow`);
+    }
+    return node.derivePath(parsedPath);
+};
+/*
+ * Takes a key expression (xpub, xprv, pubkey or wif) and returns a pubkey in
+ * binary format
+ */
+function parseKeyExpression({ keyExpression, isSegwit, ECPair, BIP32, network = bitcoinjs_lib_1.networks.bitcoin }) {
+    let pubkey;
+    let ecpair;
+    let bip32;
+    let masterFingerprint;
+    let originPath;
+    let keyPath;
+    let path;
+    //Validate the keyExpression:
+    const keyExpressions = keyExpression.match(RE.reKeyExp);
+    if (keyExpressions === null || keyExpressions[0] !== keyExpression) {
+        throw new Error(`Error: expected a keyExpression but got ${keyExpression}`);
+    }
+    const reOriginAnchoredStart = RegExp(String.raw `^(${RE.reOrigin})?`); //starts with ^origin
+    const mOrigin = keyExpression.match(reOriginAnchoredStart);
+    if (mOrigin) {
+        const bareOrigin = mOrigin[0].replace(/[[\]]/g, ''); //strip the "[" and "]" in [origin]
+        const reMasterFingerprintAnchoredStart = String.raw `^(${RE.reMasterFingerprint})`;
+        const mMasterFingerprint = bareOrigin.match(reMasterFingerprintAnchoredStart);
+        const masterFingerprintHex = mMasterFingerprint
+            ? mMasterFingerprint[0]
+            : '';
+        originPath = bareOrigin.replace(masterFingerprintHex, '');
+        if (masterFingerprintHex.length > 0) {
+            if (masterFingerprintHex.length !== 8)
+                throw new Error(`Error: masterFingerprint ${masterFingerprintHex} invalid for keyExpression: ${keyExpression}`);
+            masterFingerprint = Buffer.from(masterFingerprintHex, 'hex');
+        }
+    }
+    //Remove the origin (if it exists) and store result in actualKey
+    const actualKey = keyExpression.replace(reOriginAnchoredStart, '');
+    let mPubKey, mWIF, mXpubKey, mXprvKey;
+    //match pubkey:
+    if ((mPubKey = actualKey.match(RE.anchorStartAndEnd(RE.rePubKey))) !== null) {
+        pubkey = Buffer.from(mPubKey[0], 'hex');
+        ecpair = ECPair.fromPublicKey(pubkey, { network });
+        //Validate the pubkey (compressed or uncompressed)
+        if (!ECPair.isPoint(pubkey) ||
+            !(pubkey.length === 33 || pubkey.length === 65)) {
+            throw new Error(`Error: invalid pubkey`);
+        }
+        //Do an extra check in case we know this pubkey refers to a segwit input
+        if (typeof isSegwit === 'boolean' &&
+            isSegwit &&
+            pubkey.length !== 33 //Inside wpkh and wsh, only compressed public keys are permitted.
+        ) {
+            throw new Error(`Error: invalid pubkey`);
+        }
+        //match WIF:
+    }
+    else if ((mWIF = actualKey.match(RE.anchorStartAndEnd(RE.reWIF))) !== null) {
+        ecpair = ECPair.fromWIF(mWIF[0], network);
+        //fromWIF will throw if the wif is not valid
+        pubkey = ecpair.publicKey;
+        //match xpub:
+    }
+    else if ((mXpubKey = actualKey.match(RE.anchorStartAndEnd(RE.reXpubKey))) !== null) {
+        const xPubKey = mXpubKey[0];
+        const xPub = xPubKey.match(RE.reXpub)?.[0];
+        if (!xPub)
+            throw new Error(`Error: xpub could not be matched`);
+        bip32 = BIP32.fromBase58(xPub, network);
+        const mPath = xPubKey.match(RE.rePath);
+        if (mPath !== null) {
+            keyPath = xPubKey.match(RE.rePath)?.[0];
+            if (!keyPath)
+                throw new Error(`Error: could not extract a path`);
+            //fromBase58 and derivePath will throw if xPub or path are not valid
+            pubkey = derivePath(bip32, keyPath).publicKey;
+        }
+        else {
+            pubkey = bip32.publicKey;
+        }
+        //match xprv:
+    }
+    else if ((mXprvKey = actualKey.match(RE.anchorStartAndEnd(RE.reXprvKey))) !== null) {
+        const xPrvKey = mXprvKey[0];
+        const xPrv = xPrvKey.match(RE.reXprv)?.[0];
+        if (!xPrv)
+            throw new Error(`Error: xprv could not be matched`);
+        bip32 = BIP32.fromBase58(xPrv, network);
+        const mPath = xPrvKey.match(RE.rePath);
+        if (mPath !== null) {
+            keyPath = xPrvKey.match(RE.rePath)?.[0];
+            if (!keyPath)
+                throw new Error(`Error: could not extract a path`);
+            //fromBase58 and derivePath will throw if xPrv or path are not valid
+            pubkey = derivePath(bip32, keyPath).publicKey;
+        }
+        else {
+            pubkey = bip32.publicKey;
+        }
+    }
+    else {
+        throw new Error(`Error: could not get pubkey for keyExpression ${keyExpression}`);
+    }
+    if (masterFingerprint && (originPath || keyPath)) {
+        path = 'm' + originPath + keyPath;
+    }
+    return {
+        pubkey,
+        keyExpression,
+        ...(ecpair !== undefined ? { ecpair } : {}),
+        ...(bip32 !== undefined ? { bip32 } : {}),
+        ...(masterFingerprint !== undefined ? { masterFingerprint } : {}),
+        ...(originPath !== undefined && originPath !== '' ? { originPath } : {}),
+        ...(keyPath !== undefined && keyPath !== '' ? { keyPath } : {}),
+        ...(path !== undefined ? { path } : {})
+    };
+}
+exports.parseKeyExpression = parseKeyExpression;
+function assertChangeIndexKeyPath({ change, index, keyPath }) {
+    if (!((change === undefined && index === undefined) ||
+        (change !== undefined && index !== undefined)))
+        throw new Error(`Error: Pass change, index and network or neither`);
+    if ((change !== undefined) === (keyPath !== undefined))
+        throw new Error(`Error: Pass either change and index or a keyPath`);
+}
+async function keyExpressionLedger({ ledgerClient, ledgerState, originPath, keyPath, change, index }) {
+    assertChangeIndexKeyPath({ change, index, keyPath });
+    const masterFingerprint = await (0, ledger_1.getLedgerMasterFingerPrint)({
+        ledgerClient,
+        ledgerState
+    });
+    const origin = `[${masterFingerprint.toString('hex')}${originPath}]`;
+    const xpub = await (0, ledger_1.getLedgerXpub)({ originPath, ledgerClient, ledgerState });
+    const keyRoot = `${origin}${xpub}`;
+    if (keyPath !== undefined)
+        return `${keyRoot}${keyPath}`;
+    else
+        return `${keyRoot}/${change}/${index}`;
+}
+exports.keyExpressionLedger = keyExpressionLedger;
+function keyExpressionBIP32({ masterNode, originPath, keyPath, change, index, isPublic = true }) {
+    assertChangeIndexKeyPath({ change, index, keyPath });
+    const masterFingerprint = masterNode.fingerprint;
+    const origin = `[${masterFingerprint.toString('hex')}${originPath}]`;
+    const xpub = isPublic
+        ? masterNode.derivePath(`m${originPath}`).neutered().toBase58().toString()
+        : masterNode.derivePath(`m${originPath}`).toBase58().toString();
+    const keyRoot = `${origin}${xpub}`;
+    if (keyPath !== undefined)
+        return `${keyRoot}${keyPath}`;
+    else
+        return `${keyRoot}/${change}/${index}`;
+}
+exports.keyExpressionBIP32 = keyExpressionBIP32;

package/dist/ledger.d.ts

@@ -0,0 +1,94 @@
+/// <reference types="node" />
+import type { DescriptorInterface } from './types';
+import { AppClient } from '@bitcoinerlab/ledger';
+export declare function assertLedgerApp({ transport, name, minVersion }: {
+    transport: any;
+    name: string;
+    minVersion: string;
+}): Promise<void>;
+export type LedgerPolicy = {
+    policyName?: string;
+    ledgerTemplate: string;
+    keyRoots: string[];
+    policyId?: Buffer;
+    policyHmac?: Buffer;
+};
+export type LedgerState = {
+    masterFingerprint?: Buffer;
+    policies?: LedgerPolicy[];
+    xpubs?: {
+        [key: string]: string;
+    };
+};
+export declare function getLedgerMasterFingerPrint({ ledgerClient, ledgerState }: {
+    ledgerClient: AppClient;
+    ledgerState: LedgerState;
+}): Promise<Buffer>;
+export declare function getLedgerXpub({ originPath, ledgerClient, ledgerState }: {
+    originPath: string;
+    ledgerClient: AppClient;
+    ledgerState: LedgerState;
+}): Promise<string>;
+/**
+ * Takes a descriptor and gets its Ledger Wallet Policy, that is, its keyRoots and template.
+ * keyRoots and template follow Ledger's specifications:
+ * https://github.com/LedgerHQ/app-bitcoin-new/blob/develop/doc/wallet.md
+ *
+ * keyRoots and template are a generalization of a descriptor and serve to
+ * describe internal and external addresses and any index.
+ *
+ * So, this function starts from a descriptor and obtains generalized Ledger
+ * wallet policy.
+ *
+ * keyRoots is an array of strings, encoding xpub-type key expressions up to the origin.
+ * F.ex.: [76223a6e/48'/1'/0'/2']tpubDE7NQymr4AFtewpAsWtnreyq9ghkzQBXpCZjWLFVRAvnbf7vya2eMTvT2fPapNqL8SuVvLQdbUbMfWLVDCZKnsEBqp6UK93QEzL8Ck23AwF
+ *
+ * Template encodes the descriptor script expression, where its key
+ * expressions are represented using variables for each keyRoot and finished with "/**"
+ * (for change 1 or 0 and any index). F.ex.:
+ * wsh(sortedmulti(2,@0/**,@1/**)), where @0 corresponds the first element in the keyRoots array.
+ *
+ * If this descriptor does not contain any key that can be signed with the ledger
+ * (non-matching masterFingerprint), then this function returns null.
+ *
+ * This function takes into account all the considerations regarding Ledger
+ * policy implementation details expressed in the header of this file.
+ */
+export declare function descriptorToLedgerFormat({ descriptor, ledgerClient, ledgerState }: {
+    descriptor: DescriptorInterface;
+    ledgerClient: AppClient;
+    ledgerState: LedgerState;
+}): Promise<{
+    ledgerTemplate: string;
+    keyRoots: string[];
+} | null>;
+/**
+ * It registers a policy based on a descriptor. It stores it in ledgerState.
+ *
+ * If the policy was already registered, it does not register it.
+ * If the policy is standard, it does not register it.
+ *
+ **/
+export declare function registerLedgerWallet({ descriptor, ledgerClient, ledgerState, policyName }: {
+    descriptor: DescriptorInterface;
+    ledgerClient: AppClient;
+    ledgerState: LedgerState;
+    policyName: string;
+}): Promise<void>;
+/**
+ * Retrieve a standard ledger policy or null if it does correspond.
+ **/
+export declare function ledgerPolicyFromStandard({ descriptor, ledgerClient, ledgerState }: {
+    descriptor: DescriptorInterface;
+    ledgerClient: AppClient;
+    ledgerState: LedgerState;
+}): Promise<LedgerPolicy | null>;
+export declare function comparePolicies(policyA: LedgerPolicy, policyB: LedgerPolicy): boolean;
+/**
+ * Retrieve a ledger policy from ledgerState or null if it does not exist yet.
+ **/
+export declare function ledgerPolicyFromState({ descriptor, ledgerClient, ledgerState }: {
+    descriptor: DescriptorInterface;
+    ledgerClient: AppClient;
+    ledgerState: LedgerState;
+}): Promise<LedgerPolicy | null>;

package/dist/ledger.js

@@ -0,0 +1,283 @@
+"use strict";
+// Copyright (c) 2023 Jose-Luis Landabaso - https://bitcoinerlab.com
+// Distributed under the MIT software license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ledgerPolicyFromState = exports.comparePolicies = exports.ledgerPolicyFromStandard = exports.registerLedgerWallet = exports.descriptorToLedgerFormat = exports.getLedgerXpub = exports.getLedgerMasterFingerPrint = exports.assertLedgerApp = void 0;
+const ledger_1 = require("@bitcoinerlab/ledger");
+const bitcoinjs_lib_1 = require("bitcoinjs-lib");
+const re_1 = require("./re");
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function ledgerAppInfo(transport) {
+    const r = await transport.send(0xb0, 0x01, 0x00, 0x00);
+    let i = 0;
+    const format = r[i++];
+    const nameLength = r[i++];
+    const name = r.slice(i, (i += nameLength)).toString('ascii');
+    const versionLength = r[i++];
+    const version = r.slice(i, (i += versionLength)).toString('ascii');
+    const flagLength = r[i++];
+    const flags = r.slice(i, (i += flagLength));
+    return { name, version, flags, format };
+}
+async function assertLedgerApp({ transport, name, minVersion }) {
+    const { name: openName, version } = await ledgerAppInfo(transport);
+    if (openName !== name) {
+        throw new Error(`Open the ${name} app and try again`);
+    }
+    else {
+        const [mVmajor, mVminor, mVpatch] = minVersion.split('.').map(Number);
+        const [major, minor, patch] = version.split('.').map(Number);
+        if (mVmajor === undefined ||
+            mVminor === undefined ||
+            mVpatch === undefined) {
+            throw new Error(`Pass a minVersion using semver notation: major.minor.patch`);
+        }
+        if (major < mVmajor ||
+            (major === mVmajor && minor < mVminor) ||
+            (major === mVmajor && minor === mVminor && patch < mVpatch))
+            throw new Error(`Error: please upgrade ${name} to version ${minVersion}`);
+    }
+}
+exports.assertLedgerApp = assertLedgerApp;
+function isLedgerStandard({ ledgerTemplate, keyRoots, network = bitcoinjs_lib_1.networks.bitcoin }) {
+    if (keyRoots.length !== 1)
+        return false;
+    const originPath = keyRoots[0]?.match(re_1.reOriginPath)?.[1];
+    if (!originPath)
+        return false;
+    //Network is the 6th character: /44'/0'
+    if (originPath[5] !== (network === bitcoinjs_lib_1.networks.bitcoin ? '0' : '1'))
+        return false;
+    if ((ledgerTemplate === 'pkh(@0/**)' &&
+        originPath.match(/^\/44'\/[01]'\/(\d+)'$/)) ||
+        (ledgerTemplate === 'wpkh(@0/**)' &&
+            originPath.match(/^\/84'\/[01]'\/(\d+)'$/)) ||
+        (ledgerTemplate === 'sh(wpkh(@0/**))' &&
+            originPath.match(/^\/49'\/[01]'\/(\d+)'$/)) ||
+        (ledgerTemplate === 'tr(@0/**)' &&
+            originPath.match(/^\/86'\/[01]'\/(\d+)'$/)))
+        return true;
+    return false;
+}
+async function getLedgerMasterFingerPrint({ ledgerClient, ledgerState }) {
+    let masterFingerprint = ledgerState.masterFingerprint;
+    if (!masterFingerprint) {
+        masterFingerprint = Buffer.from(await ledgerClient.getMasterFingerprint(), 'hex');
+        ledgerState.masterFingerprint = masterFingerprint;
+    }
+    return masterFingerprint;
+}
+exports.getLedgerMasterFingerPrint = getLedgerMasterFingerPrint;
+async function getLedgerXpub({ originPath, ledgerClient, ledgerState }) {
+    if (!ledgerState.xpubs)
+        ledgerState.xpubs = {};
+    let xpub = ledgerState.xpubs[originPath];
+    if (!xpub) {
+        try {
+            //Try getting the xpub without user confirmation
+            xpub = await ledgerClient.getExtendedPubkey(`m${originPath}`, false);
+        }
+        catch (err) {
+            xpub = await ledgerClient.getExtendedPubkey(`m${originPath}`, true);
+        }
+        ledgerState.xpubs[originPath] = xpub;
+    }
+    return xpub;
+}
+exports.getLedgerXpub = getLedgerXpub;
+/**
+ * Takes a descriptor and gets its Ledger Wallet Policy, that is, its keyRoots and template.
+ * keyRoots and template follow Ledger's specifications:
+ * https://github.com/LedgerHQ/app-bitcoin-new/blob/develop/doc/wallet.md
+ *
+ * keyRoots and template are a generalization of a descriptor and serve to
+ * describe internal and external addresses and any index.
+ *
+ * So, this function starts from a descriptor and obtains generalized Ledger
+ * wallet policy.
+ *
+ * keyRoots is an array of strings, encoding xpub-type key expressions up to the origin.
+ * F.ex.: [76223a6e/48'/1'/0'/2']tpubDE7NQymr4AFtewpAsWtnreyq9ghkzQBXpCZjWLFVRAvnbf7vya2eMTvT2fPapNqL8SuVvLQdbUbMfWLVDCZKnsEBqp6UK93QEzL8Ck23AwF
+ *
+ * Template encodes the descriptor script expression, where its key
+ * expressions are represented using variables for each keyRoot and finished with "/**"
+ * (for change 1 or 0 and any index). F.ex.:
+ * wsh(sortedmulti(2,@0/**,@1/**)), where @0 corresponds the first element in the keyRoots array.
+ *
+ * If this descriptor does not contain any key that can be signed with the ledger
+ * (non-matching masterFingerprint), then this function returns null.
+ *
+ * This function takes into account all the considerations regarding Ledger
+ * policy implementation details expressed in the header of this file.
+ */
+async function descriptorToLedgerFormat({ descriptor, ledgerClient, ledgerState }) {
+    const expandedExpression = descriptor.expand().expandedExpression;
+    const expansionMap = descriptor.expand().expansionMap;
+    if (!expandedExpression || !expansionMap)
+        throw new Error(`Error: invalid descriptor`);
+    const ledgerMasterFingerprint = await getLedgerMasterFingerPrint({
+        ledgerClient,
+        ledgerState
+    });
+    //It's important to have keys sorted in ascii order. keys
+    //are of this type: @0, @1, @2, ....  and they also appear in the expandedExpression
+    //in ascending ascii order. Note that Object.keys(expansionMap ) does not ensure
+    //that the order is respected and so we force it.
+    const allKeys = Object.keys(expansionMap).sort();
+    const ledgerKeys = allKeys.filter(key => {
+        const masterFingerprint = expansionMap[key]?.masterFingerprint;
+        return (masterFingerprint &&
+            Buffer.compare(masterFingerprint, ledgerMasterFingerprint) === 0);
+    });
+    if (ledgerKeys.length === 0)
+        return null;
+    if (ledgerKeys.length > 1)
+        throw new Error(`Error: descriptor ${expandedExpression} does not contain exactly 1 ledger key`);
+    const ledgerKey = ledgerKeys[0];
+    const masterFingerprint = expansionMap[ledgerKey].masterFingerprint;
+    const originPath = expansionMap[ledgerKey].originPath;
+    const keyPath = expansionMap[ledgerKey].keyPath;
+    const bip32 = expansionMap[ledgerKey].bip32;
+    if (!masterFingerprint || !originPath || !keyPath || !bip32) {
+        throw new Error(`Error: Ledger key expression must have a valid masterFingerprint: ${masterFingerprint}, originPath: ${originPath}, keyPath: ${keyPath} and a valid bip32 node`);
+    }
+    if (!/^\/[01]\/\d+$/.test(keyPath))
+        throw new Error(`Error: key paths must be /<1;0>/index, where change is 1 or 0 and index >= 0`);
+    const keyRoots = [];
+    let ledgerTemplate = expandedExpression;
+    allKeys.forEach(key => {
+        if (key !== ledgerKey) {
+            //This block here only does data integrity assertions:
+            const otherKeyInfo = expansionMap[key];
+            if (!otherKeyInfo.bip32) {
+                throw new Error(`Error: ledger only allows xpub-type key expressions`);
+            }
+            if (otherKeyInfo.originPath) {
+                if (otherKeyInfo.originPath !== originPath) {
+                    throw new Error(`Error: all originPaths must be the same for Ledger being able to sign. On the other hand, you can leave the origin info empty for external keys: ${otherKeyInfo.originPath} !== ${originPath}`);
+                }
+            }
+            if (otherKeyInfo.keyPath !== keyPath) {
+                throw new Error(`Error: all keyPaths must be the same for Ledger being able to sign: ${otherKeyInfo.keyPath} !== ${keyPath}`);
+            }
+        }
+        ledgerTemplate = ledgerTemplate.replaceAll(key, `@${keyRoots.length}/**`);
+        const keyInfo = expansionMap[key];
+        if (keyInfo.masterFingerprint && keyInfo.originPath)
+            keyRoots.push(`[${keyInfo.masterFingerprint?.toString('hex')}${keyInfo.originPath}]${keyInfo?.bip32?.neutered().toBase58()}`);
+        else
+            keyRoots.push(`${keyInfo?.bip32?.neutered().toBase58()}`);
+    });
+    return { ledgerTemplate, keyRoots };
+}
+exports.descriptorToLedgerFormat = descriptorToLedgerFormat;
+/**
+ * It registers a policy based on a descriptor. It stores it in ledgerState.
+ *
+ * If the policy was already registered, it does not register it.
+ * If the policy is standard, it does not register it.
+ *
+ **/
+async function registerLedgerWallet({ descriptor, ledgerClient, ledgerState, policyName }) {
+    const result = await descriptorToLedgerFormat({
+        descriptor,
+        ledgerClient,
+        ledgerState
+    });
+    if (await ledgerPolicyFromStandard({ descriptor, ledgerClient, ledgerState }))
+        return;
+    if (!result)
+        throw new Error(`Error: descriptor does not have a ledger input`);
+    const { ledgerTemplate, keyRoots } = result;
+    if (!ledgerState.policies)
+        ledgerState.policies = [];
+    let walletPolicy, policyHmac;
+    //Search in ledgerState first
+    const policy = await ledgerPolicyFromState({
+        descriptor,
+        ledgerClient,
+        ledgerState
+    });
+    if (policy) {
+        if (policy.policyName !== policyName)
+            throw new Error(`Error: policy was already registered with a different name: ${policy.policyName}`);
+        //It already existed. No need to register it again.
+    }
+    else {
+        walletPolicy = new ledger_1.WalletPolicy(policyName, ledgerTemplate, keyRoots);
+        let policyId;
+        [policyId, policyHmac] = await ledgerClient.registerWallet(walletPolicy);
+        const policy = {
+            policyName,
+            ledgerTemplate,
+            keyRoots,
+            policyId,
+            policyHmac
+        };
+        ledgerState.policies.push(policy);
+    }
+}
+exports.registerLedgerWallet = registerLedgerWallet;
+/**
+ * Retrieve a standard ledger policy or null if it does correspond.
+ **/
+async function ledgerPolicyFromStandard({ descriptor, ledgerClient, ledgerState }) {
+    const result = await descriptorToLedgerFormat({
+        descriptor,
+        ledgerClient,
+        ledgerState
+    });
+    if (!result)
+        throw new Error(`Error: descriptor does not have a ledger input`);
+    const { ledgerTemplate, keyRoots } = result;
+    if (isLedgerStandard({
+        ledgerTemplate,
+        keyRoots,
+        network: descriptor.getNetwork()
+    }))
+        return { ledgerTemplate, keyRoots };
+    return null;
+}
+exports.ledgerPolicyFromStandard = ledgerPolicyFromStandard;
+function compareKeyRoots(arr1, arr2) {
+    if (arr1.length !== arr2.length) {
+        return false;
+    }
+    for (let i = 0; i < arr1.length; i++) {
+        if (arr1[i] !== arr2[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+function comparePolicies(policyA, policyB) {
+    return (compareKeyRoots(policyA.keyRoots, policyB.keyRoots) &&
+        policyA.ledgerTemplate === policyB.ledgerTemplate);
+}
+exports.comparePolicies = comparePolicies;
+/**
+ * Retrieve a ledger policy from ledgerState or null if it does not exist yet.
+ **/
+async function ledgerPolicyFromState({ descriptor, ledgerClient, ledgerState }) {
+    const result = await descriptorToLedgerFormat({
+        descriptor,
+        ledgerClient,
+        ledgerState
+    });
+    if (!result)
+        throw new Error(`Error: descriptor does not have a ledger input`);
+    const { ledgerTemplate, keyRoots } = result;
+    if (!ledgerState.policies)
+        ledgerState.policies = [];
+    //Search in ledgerState:
+    const policies = ledgerState.policies.filter(policy => comparePolicies(policy, { ledgerTemplate, keyRoots }));
+    if (policies.length > 1)
+        throw new Error(`Error: duplicated policy`);
+    if (policies.length === 1) {
+        return policies[0];
+    }
+    else {
+        return null;
+    }
+}
+exports.ledgerPolicyFromState = ledgerPolicyFromState;