@bitcoinerlab/descriptors 2.3.6 → 3.0.1

package/dist/index.d.ts

@@ -1,35 +1,8 @@
-export type { KeyInfo, Expansion } from './types';
-import type { Psbt } from 'bitcoinjs-lib';
-import type { DescriptorInstance, OutputInstance } from './descriptors';
-export { DescriptorsFactory, DescriptorInstance, DescriptorConstructor, OutputInstance, OutputConstructor } from './descriptors';
+export type { Expansion, ExpansionMap, KeyExpressionParser, KeyInfo, Preimage, TimeConstraints } from './types';
+export { DescriptorsFactory, OutputInstance, OutputConstructor } from './descriptors';
 export { DescriptorChecksum as checksum } from './checksum';
 import * as signers from './signers';
 export { signers };
-/**
- * @hidden @deprecated
- * To finalize the `psbt`, you can either call the method
- * `output.finalizePsbtInput({ index, psbt })` on each descriptor, passing as
- * arguments the `psbt` and its input `index`, or call this helper function:
- * `finalizePsbt({psbt, outputs })`. In the latter case, `outputs` is an
- * array of {@link _Internal_.Output | Output elements} ordered in the array by
- * their respective input index in the `psbt`.
- */
-declare function finalizePsbt(params: {
-    psbt: Psbt;
-    outputs: OutputInstance[];
-    validate?: boolean | undefined;
-}): void;
-/**
- * @deprecated
- * @hidden
- * To be removed in version 3.0
- */
-declare function finalizePsbt(params: {
-    psbt: Psbt;
-    descriptors: DescriptorInstance[];
-    validate?: boolean | undefined;
-}): void;
-export { finalizePsbt };
 export { keyExpressionBIP32, keyExpressionLedger } from './keyExpressions';
 import * as scriptExpressions from './scriptExpressions';
 export { scriptExpressions };

package/dist/index.js

@@ -36,7 +36,6 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ledger = exports.scriptExpressions = exports.keyExpressionLedger = exports.keyExpressionBIP32 = exports.signers = exports.checksum = exports.DescriptorsFactory = void 0;
-exports.finalizePsbt = finalizePsbt;
 // Some dependencies (like hash-base) assume process.version exists.
 // In React Native / Hermes, process is defined but version is not.
 // Note: we only polyfill if process already exists but is incomplete.
@@ -67,19 +66,6 @@ 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;
-/**
- * @hidden
- * To be removed in v3.0 and replaced by the version with the signature that
- * does not accept descriptors
- */
-function finalizePsbt({ psbt, outputs, descriptors, validate = true }) {
-    if (descriptors && outputs)
-        throw new Error(`descriptors param has been deprecated`);
-    outputs = descriptors || outputs;
-    if (!outputs)
-        throw new Error(`outputs not provided`);
-    outputs.forEach((output, inputIndex) => output.finalizePsbtInput({ index: inputIndex, psbt, validate }));
-}
 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; } });

package/dist/keyExpressions.d.ts

@@ -2,7 +2,7 @@ import { Network } from 'bitcoinjs-lib';
 import type { ECPairAPI } from 'ecpair';
 import type { BIP32API, BIP32Interface } from 'bip32';
 import type { KeyInfo } from './types';
-import { LedgerState, LedgerManager } from './ledger';
+import { LedgerManager } from './ledger';
 /**
  * Parses a key expression (xpub, xprv, pubkey or wif) into {@link KeyInfo | `KeyInfo`}.
  *
@@ -49,7 +49,7 @@ export declare function parseKeyExpression({ keyExpression, isSegwit, isTaproot,
  *
  * For detailed understanding and examples of terms like `originPath`,
  * `change`, and `keyPath`, refer to the documentation of
- * {@link _Internal_.ParseKeyExpression | ParseKeyExpression}, which consists
+ * {@link _Internal_.KeyExpressionParser | KeyExpressionParser}, which consists
  * of the reverse procedure.
  *
  * @returns {string} - The formed key expression for the Ledger device.
@@ -61,22 +61,13 @@ export declare function keyExpressionLedger({ ledgerManager, originPath, keyPath
     index?: number | undefined | '*';
     keyPath?: string | undefined;
 }): Promise<string>;
-/** @hidden */
-export declare function keyExpressionLedger({ ledgerClient, ledgerState, originPath, keyPath, change, index }: {
-    ledgerClient: unknown;
-    ledgerState: LedgerState;
-    originPath: string;
-    change?: number | undefined;
-    index?: number | undefined | '*';
-    keyPath?: string | undefined;
-}): Promise<string>;
 /**
  * Constructs a key expression string from its constituent components.
  *
  * This function essentially performs the reverse operation of
- * {@link _Internal_.ParseKeyExpression | ParseKeyExpression}. For detailed
+ * {@link _Internal_.KeyExpressionParser | KeyExpressionParser}. For detailed
  * explanations and examples of the terms used here, refer to
- * {@link _Internal_.ParseKeyExpression | ParseKeyExpression}.
+ * {@link _Internal_.KeyExpressionParser | KeyExpressionParser}.
  */
 export declare function keyExpressionBIP32({ masterNode, originPath, keyPath, change, index, isPublic }: {
     masterNode: BIP32Interface;

package/dist/keyExpressions.js

@@ -40,6 +40,7 @@ exports.keyExpressionLedger = keyExpressionLedger;
 exports.keyExpressionBIP32 = keyExpressionBIP32;
 const bitcoinjs_lib_1 = require("bitcoinjs-lib");
 const ledger_1 = require("./ledger");
+const uint8array_tools_1 = require("uint8array-tools");
 const RE = __importStar(require("./re"));
 const derivePath = (node, path) => {
     if (typeof path !== 'string') {
@@ -72,6 +73,8 @@ const derivePath = (node, path) => {
  * ```
  */
 function parseKeyExpression({ keyExpression, isSegwit, isTaproot, ECPair, BIP32, network = bitcoinjs_lib_1.networks.bitcoin }) {
+    if (isTaproot && isSegwit !== true)
+        throw new Error(`Error: taproot key expressions require isSegwit`);
     let pubkey; //won't be computed for ranged keyExpressions
     let ecpair;
     let bip32;
@@ -108,7 +111,7 @@ function parseKeyExpression({ keyExpression, isSegwit, isTaproot, ECPair, BIP32,
         if (masterFingerprintHex.length > 0) {
             if (masterFingerprintHex.length !== 8)
                 throw new Error(`Error: masterFingerprint ${masterFingerprintHex} invalid for keyExpression: ${keyExpression}`);
-            masterFingerprint = Buffer.from(masterFingerprintHex, 'hex');
+            masterFingerprint = (0, uint8array_tools_1.fromHex)(masterFingerprintHex);
         }
     }
     //Remove the origin (if it exists) and store result in actualKey
@@ -116,10 +119,10 @@ function parseKeyExpression({ keyExpression, isSegwit, isTaproot, ECPair, BIP32,
     let mPubKey, mWIF, mXpubKey, mXprvKey;
     //match pubkey:
     if ((mPubKey = actualKey.match(RE.anchorStartAndEnd(rePubKey))) !== null) {
-        pubkey = Buffer.from(mPubKey[0], 'hex');
+        pubkey = (0, uint8array_tools_1.fromHex)(mPubKey[0]);
         if (isTaproot && pubkey.length === 32)
             //convert the xonly point to a compressed point assuming even parity
-            pubkey = Buffer.concat([Buffer.from([0x02]), pubkey]);
+            pubkey = (0, uint8array_tools_1.concat)([Uint8Array.from([0x02]), pubkey]);
         ecpair = ECPair.fromPublicKey(pubkey, { network });
         //Validate the pubkey (compressed or uncompressed)
         if (!ECPair.isPoint(pubkey) ||
@@ -127,6 +130,7 @@ function parseKeyExpression({ keyExpression, isSegwit, isTaproot, ECPair, BIP32,
             throw new Error(`Error: invalid pubkey`);
         }
         //Do an extra check in case we know this pubkey refers to a segwit input
+        //Taproot x-only keys are converted to 33-byte compressed form above.
         if (typeof isSegwit === 'boolean' &&
             isSegwit &&
             pubkey.length !== 33 //Inside wpkh and wsh, only compressed public keys are permitted.
@@ -207,21 +211,14 @@ function assertChangeIndexKeyPath({ change, index, keyPath }) {
     if ((change !== undefined) === (keyPath !== undefined))
         throw new Error(`Error: Pass either change and index or a keyPath`);
 }
-/** @overload */
-async function keyExpressionLedger({ ledgerClient, ledgerState, ledgerManager, originPath, keyPath, change, index }) {
-    if (ledgerManager && (ledgerClient || ledgerState))
-        throw new Error(`ledgerClient and ledgerState have been deprecated`);
-    if (ledgerManager)
-        ({ ledgerClient, ledgerState } = ledgerManager);
-    if (!ledgerClient || !ledgerState)
-        throw new Error(`Could not retrieve ledgerClient or ledgerState`);
+/** @hidden */
+async function keyExpressionLedger({ ledgerManager, originPath, keyPath, change, index }) {
     assertChangeIndexKeyPath({ change, index, keyPath });
     const masterFingerprint = await (0, ledger_1.getLedgerMasterFingerPrint)({
-        ledgerClient,
-        ledgerState
+        ledgerManager
     });
-    const origin = `[${masterFingerprint.toString('hex')}${originPath}]`;
-    const xpub = await (0, ledger_1.getLedgerXpub)({ originPath, ledgerClient, ledgerState });
+    const origin = `[${(0, uint8array_tools_1.toHex)(masterFingerprint)}${originPath}]`;
+    const xpub = await (0, ledger_1.getLedgerXpub)({ originPath, ledgerManager });
     const keyRoot = `${origin}${xpub}`;
     if (keyPath !== undefined)
         return `${keyRoot}${keyPath}`;
@@ -232,14 +229,14 @@ async function keyExpressionLedger({ ledgerClient, ledgerState, ledgerManager, o
  * Constructs a key expression string from its constituent components.
  *
  * This function essentially performs the reverse operation of
- * {@link _Internal_.ParseKeyExpression | ParseKeyExpression}. For detailed
+ * {@link _Internal_.KeyExpressionParser | KeyExpressionParser}. For detailed
  * explanations and examples of the terms used here, refer to
- * {@link _Internal_.ParseKeyExpression | ParseKeyExpression}.
+ * {@link _Internal_.KeyExpressionParser | KeyExpressionParser}.
  */
 function keyExpressionBIP32({ masterNode, originPath, keyPath, change, index, isPublic = true }) {
     assertChangeIndexKeyPath({ change, index, keyPath });
     const masterFingerprint = masterNode.fingerprint;
-    const origin = `[${masterFingerprint.toString('hex')}${originPath}]`;
+    const origin = `[${(0, uint8array_tools_1.toHex)(masterFingerprint)}${originPath}]`;
     const xpub = isPublic
         ? masterNode.derivePath(`m${originPath}`).neutered().toBase58().toString()
         : masterNode.derivePath(`m${originPath}`).toBase58().toString();

package/dist/ledger.d.ts

@@ -1,14 +1,14 @@
-import { DescriptorInstance, OutputInstance } from './descriptors';
+import { OutputInstance } from './descriptors';
 import { Network, Psbt } from 'bitcoinjs-lib';
 import type { TinySecp256k1Interface } from './types';
 /**
- * Dynamically imports the 'ledger-bitcoin' module and, if provided, checks if `ledgerClient` is an instance of `AppClient`.
+ * Dynamically imports the '@ledgerhq/ledger-bitcoin' module and, if provided, checks if `ledgerClient` is an instance of `AppClient`.
  *
  * @async
  * @param {unknown} ledgerClient - An optional parameter that, if provided, is checked to see if it's an instance of `AppClient`.
  * @throws {Error} Throws an error if `ledgerClient` is provided but is not an instance of `AppClient`.
- * @throws {Error} Throws an error if the 'ledger-bitcoin' module cannot be imported. This typically indicates that the 'ledger-bitcoin' peer dependency is not installed.
- * @returns {Promise<unknown>} Returns a promise that resolves with the entire 'ledger-bitcoin' module if it can be successfully imported. We force it to return an unknown type so that the declaration of this function won't break projects that don't use ledger-bitcoin as dependency
+ * @throws {Error} Throws an error if the '@ledgerhq/ledger-bitcoin' module cannot be imported. This typically indicates that the '@ledgerhq/ledger-bitcoin' peer dependency is not installed.
+ * @returns {Promise<unknown>} Returns a promise that resolves with the entire '@ledgerhq/ledger-bitcoin' module if it can be successfully imported. We force it to return an unknown type so that the declaration of this function won't break projects that don't use @ledgerhq/ledger-bitcoin as dependency
  *
  * @example
  *
@@ -48,8 +48,8 @@ export type LedgerPolicy = {
     policyName?: string;
     ledgerTemplate: string;
     keyRoots: string[];
-    policyId?: Buffer;
-    policyHmac?: Buffer;
+    policyId?: Uint8Array;
+    policyHmac?: Uint8Array;
 };
 /**
  * Ledger devices operate in a state-less manner. Therefore, policy information
@@ -57,7 +57,7 @@ export type LedgerPolicy = {
  * `ledgerState` also stores cached xpubs and the masterFingerprint.
  */
 export type LedgerState = {
-    masterFingerprint?: Buffer;
+    masterFingerprint?: Uint8Array;
     policies?: LedgerPolicy[];
     xpubs?: {
         [key: string]: string;
@@ -74,12 +74,7 @@ export type LedgerManager = {
  */
 export declare function getLedgerMasterFingerPrint({ ledgerManager }: {
     ledgerManager: LedgerManager;
-}): Promise<Buffer>;
-/** @hidden */
-export declare function getLedgerMasterFingerPrint({ ledgerClient, ledgerState }: {
-    ledgerClient: unknown;
-    ledgerState: LedgerState;
-}): Promise<Buffer>;
+}): Promise<Uint8Array>;
 /**
  * Retrieves the xpub of a certain originPath of a Ledger device
  */
@@ -87,12 +82,6 @@ export declare function getLedgerXpub({ originPath, ledgerManager }: {
     originPath: string;
     ledgerManager: LedgerManager;
 }): Promise<string>;
-/** @deprecated @hidden */
-export declare function getLedgerXpub({ originPath, ledgerClient, ledgerState }: {
-    originPath: string;
-    ledgerClient: unknown;
-    ledgerState: LedgerState;
-}): Promise<string>;
 /**
  * Checks whether there is a policy in ledgerState that the ledger
  * could use to sign this psbt input.
@@ -133,10 +122,9 @@ export declare function ledgerPolicyFromPsbtInput({ ledgerManager, psbt, index }
  * This function takes into account all the considerations regarding Ledger
  * policy implementation details expressed in the header of this file.
  */
-export declare function ledgerPolicyFromOutput({ output, ledgerClient, ledgerState }: {
+export declare function ledgerPolicyFromOutput({ output, ledgerManager }: {
     output: OutputInstance;
-    ledgerClient: unknown;
-    ledgerState: LedgerState;
+    ledgerManager: LedgerManager;
 }): Promise<{
     ledgerTemplate: string;
     keyRoots: string[];
@@ -162,29 +150,18 @@ export declare function registerLedgerWallet({ descriptor, ledgerManager, policy
     /** The Name we want to assign to this specific policy */
     policyName: string;
 }): Promise<void>;
-/**
- * @hidden
- */
-export declare function registerLedgerWallet({ descriptor, ledgerClient, ledgerState, policyName }: {
-    descriptor: DescriptorInstance;
-    ledgerClient: unknown;
-    ledgerState: LedgerState;
-    policyName: string;
-}): Promise<void>;
 /**
  * Retrieve a standard ledger policy or null if it does correspond.
  **/
-export declare function ledgerPolicyFromStandard({ output, ledgerClient, ledgerState }: {
+export declare function ledgerPolicyFromStandard({ output, ledgerManager }: {
     output: OutputInstance;
-    ledgerClient: unknown;
-    ledgerState: LedgerState;
+    ledgerManager: LedgerManager;
 }): 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({ output, ledgerClient, ledgerState }: {
+export declare function ledgerPolicyFromState({ output, ledgerManager }: {
     output: OutputInstance;
-    ledgerClient: unknown;
-    ledgerState: LedgerState;
+    ledgerManager: LedgerManager;
 }): Promise<LedgerPolicy | null>;