@bitcoinerlab/descriptors 0.3.0 → 1.0.0

package/README.md

@@ -79,8 +79,8 @@ constructor({
               // to denote an arbitrary index.
   index,      // The descriptor's index in the case of a range descriptor
               // (must be an integer >= 0).
-  checksumRequired = false, // Flag indicating if the descriptor is required
-                            // to include a checksum.
+  checksumRequired = false // Optional flag indicating if the descriptor is
+                           // required to include a checksum. Defaults to false.
   allowMiniscriptInP2SH = false, // Flag indicating if this instance can parse
                                  // and generate script satisfactions for
                                  // sh(miniscript) top-level expressions of
@@ -142,7 +142,15 @@ const result = expand({
   network: networks.testnet, // One of bitcoinjs-lib `networks`
                              // (https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/src/networks.js)
                              // or another one with the same interface.
-  allowMiniscriptInP2SH: true // Optional flag to allow miniscript in P2SH
+                             // Optional (defaults to bitcoin mainnet). 
+  allowMiniscriptInP2SH: true, // Optional flag to allow miniscript in P2SH.
+                              // Defaults to false.
+  index, // Optional. The descriptor's index in the case of a range descriptor
+         // (must be an integer >= 0). If not set for ranged descriptors, then 
+         // the function will return an expansionMap with ranged keyPaths and
+         // won't compute Payment or scripts.
+  checksumRequired = false // Optional flag indicating if the descriptor is
+                           // required to include a checksum. Defaults to false.
 });
 ```
 
@@ -156,6 +164,8 @@ The `expand()` function returns an object with the following properties:
 - `expandedMiniscript: string | undefined`: The expanded miniscript, if any.
 - `redeemScript: Buffer | undefined`: The redeem script for the descriptor, if applicable.
 - `witnessScript: Buffer | undefined`: The witness script for the descriptor, if applicable.
+- `isRanged: boolean` : Whether the expression represents a ranged descriptor.
+- `canonicalExpression` : This is the preferred or authoritative representation of the descriptor expression. It standardizes the descriptor by replacing indexes on wildcards and eliminating checksums.
 
 For the example expression provided, the `expandedExpression` and a portion of the `expansionMap` would be as follows:
 
@@ -263,15 +273,26 @@ To finalize the `psbt`, you can either call the method `finalizePsbtInput({ inde
 
 This library currently provides integration with Ledger wallets. Support for more devices is planned.
 
-To use a Ledger device for signing, you can import the necessary functions as follows:
+Before we dive in, note that, in addition to the documentation below, it is highly recommended to visit the [Ledger Playground](https://bitcoinerlab.com/guides/ledger-programming) with an interactive code sandbox of this lib interacting with a Ledger device.
+
+To use this library with Ledger devices, you must first install Ledger support:
+
+```bash
+npm install ledger-bitcoin
+```
+
+For Ledger device signing, import the necessary functions as follows:
 
 ```javascript
+import Transport from '@ledgerhq/hw-transport-node-hid'; //or hw-transport-web-hid, for web
+import { AppClient } from 'ledger-bitcoin';
 import { ledger } from '@bitcoinerlab/descriptors';
 ```
 
-You can then use the following code to assert that the Ledger app is running Bitcoin Test version 2.1.0 or higher, and to create a new Ledger client:
+Then, use the following code to assert that the Ledger app is running Bitcoin Test version 2.1.0 or higher, and to create a new Ledger client:
 
 ```javascript
+const transport = await Transport.create();
 //Throws if not running Bitcoin Test >= 2.1.0
 await ledger.assertLedgerApp({
   transport,
@@ -279,12 +300,12 @@ await ledger.assertLedgerApp({
   minVersion: '2.1.0'
 });
 
-const ledgerClient = new ledger.AppClient(transport);
+const ledgerClient = new AppClient(transport);
 ```
 
 Here, `transport` is an instance of a Transport object that allows communication with Ledger devices. You can use any of the transports [provided by Ledger](https://github.com/LedgerHQ/ledger-live#libs---libraries).
 
-To register the policies of non-standard descriptors on the Ledger device, you can use the following code:
+To register the policies of non-standard descriptors on the Ledger device, use the following code:
 
 ```javascript
 await ledger.registerLedgerWallet({
@@ -297,7 +318,7 @@ await ledger.registerLedgerWallet({
 
 This code will auto-skip the policy registration process if it already exists. Please refer to [Ledger documentation](https://github.com/LedgerHQ/app-bitcoin-new/blob/develop/doc/wallet.md) to learn more about their Wallet Policies registration procedures.
 
-Finally, `ledgerState` is an object used to store information related to Ledger devices. Although Ledger devices themselves are stateless, this object can be used to store information such as xpubs, master fingerprints, and wallet policies. You can pass an initially empty object that will be updated with more information as it is used. The object can be serialized and stored.
+Finally, `ledgerState` is an object used to store information related to Ledger devices. Although Ledger devices themselves are stateless, this object can be used to store information such as xpubs, master fingerprints, and wallet policies. You can pass an initially empty object that will be updated with more information as it is used. The object can be serialized and stored for future use.
 
 <a name="documentation"></a>
 

package/dist/descriptors.js

@@ -55,7 +55,7 @@ function countNonPushOnlyOPs(script) {
     const decompile = bitcoinjs_lib_1.script.decompile(script);
     if (!decompile)
         throw new Error(`Error: cound not decompile ${script}`);
-    return decompile.filter(op => op > bitcoinjs_lib_1.script.OPS['OP_16']).length;
+    return decompile.filter(op => typeof op === 'number' && op > bitcoinjs_lib_1.script.OPS['OP_16']).length;
 }
 /*
  * Returns a bare descriptor without checksum and particularized for a certain
@@ -75,20 +75,20 @@ function evaluate({ expression, checksumRequired, index }) {
             throw new Error(`Error: invalid descriptor checksum for ${expression}`);
         }
     }
-    const mWildcard = evaluatedExpression.match(/\*/g);
-    if (mWildcard && mWildcard.length > 0) {
-        if (index === undefined)
-            throw new Error(`Error: index was not provided for ranged descriptor`);
-        if (!Number.isInteger(index) || index < 0)
-            throw new Error(`Error: invalid index ${index}`);
-        //From  https://github.com/bitcoin/bitcoin/blob/master/doc/descriptors.md
-        //To prevent a combinatorial explosion of the search space, if more than
-        //one of the multi() key arguments is a BIP32 wildcard path ending in /* or
-        //*', the multi() expression only matches multisig scripts with the ith
-        //child key from each wildcard path in lockstep, rather than scripts with
-        //any combination of child keys from each wildcard path.
-        //We extend this reasoning for musig for all cases
-        evaluatedExpression = evaluatedExpression.replaceAll('*', index.toString());
+    if (index !== undefined) {
+        const mWildcard = evaluatedExpression.match(/\*/g);
+        if (mWildcard && mWildcard.length > 0) {
+            //From  https://github.com/bitcoin/bitcoin/blob/master/doc/descriptors.md
+            //To prevent a combinatorial explosion of the search space, if more than
+            //one of the multi() key arguments is a BIP32 wildcard path ending in /* or
+            //*', the multi() expression only matches multisig scripts with the ith
+            //child key from each wildcard path in lockstep, rather than scripts with
+            //any combination of child keys from each wildcard path.
+            //We extend this reasoning for musig for all cases
+            evaluatedExpression = evaluatedExpression.replaceAll('*', index.toString());
+        }
+        else
+            throw new Error(`Error: index passed for non-ranged descriptor: ${expression}`);
     }
     return evaluatedExpression;
 }
@@ -132,13 +132,15 @@ function DescriptorsFactory(ecc) {
      *     - expandedMiniscript: The expanded miniscript, if any.
      *     - redeemScript: The redeem script for the descriptor, if applicable.
      *     - witnessScript: The witness script for the descriptor, if applicable.
+     *     - isRanged: Whether this expression representas a ranged-descriptor
+     *     - canonicalExpression: This is the preferred or authoritative
+     *     representation of the descriptor expression. It standardizes the
+     *     descriptor by replacing indexes on wildcards and eliminating checksums.
+     *     This helps ensure consistency and facilitates efficient interpretation and handling by systems or software.
      *
      * @throws {Error} Throws an error if the descriptor cannot be parsed or does not conform to the expected format.
      */
-    const expand = ({ expression, loggedExpression, //this is the expression that will be used for logging error messages
-    network = bitcoinjs_lib_1.networks.bitcoin, allowMiniscriptInP2SH = false }) => {
-        //remove the checksum before proceeding:
-        expression = expression.replace(new RegExp(RE.reChecksum + '$'), '');
+    const expand = ({ expression, index, checksumRequired = false, network = bitcoinjs_lib_1.networks.bitcoin, allowMiniscriptInP2SH = false }) => {
         let expandedExpression;
         let miniscript;
         let expansionMap;
@@ -148,15 +150,24 @@ function DescriptorsFactory(ecc) {
         let witnessScript;
         let redeemScript;
         const isRanged = expression.indexOf('*') !== -1;
-        if (!loggedExpression)
-            loggedExpression = expression;
+        if (index !== undefined)
+            if (!Number.isInteger(index) || index < 0)
+                throw new Error(`Error: invalid index ${index}`);
+        //Verify and remove checksum (if exists) and
+        //particularize range descriptor for index (if desc is range descriptor)
+        const canonicalExpression = evaluate({
+            expression,
+            ...(index !== undefined ? { index } : {}),
+            checksumRequired
+        });
+        const isCanonicalRanged = canonicalExpression.indexOf('*') !== -1;
         //addr(ADDR)
-        if (expression.match(RE.reAddrAnchored)) {
+        if (canonicalExpression.match(RE.reAddrAnchored)) {
             if (isRanged)
                 throw new Error(`Error: addr() cannot be ranged`);
-            const matchedAddress = expression.match(RE.reAddrAnchored)?.[1]; //[1]-> whatever is found addr(->HERE<-)
+            const matchedAddress = canonicalExpression.match(RE.reAddrAnchored)?.[1]; //[1]-> whatever is found addr(->HERE<-)
             if (!matchedAddress)
-                throw new Error(`Error: could not get an address in ${loggedExpression}`);
+                throw new Error(`Error: could not get an address in ${expression}`);
             let output;
             try {
                 output = bitcoinjs_lib_1.address.toOutputScript(matchedAddress, network);
@@ -189,98 +200,94 @@ function DescriptorsFactory(ecc) {
             }
         }
         //pk(KEY)
-        else if (expression.match(RE.rePkAnchored)) {
+        else if (canonicalExpression.match(RE.rePkAnchored)) {
             isSegwit = false;
-            const keyExpression = expression.match(RE.reKeyExp)?.[0];
+            const keyExpression = canonicalExpression.match(RE.reKeyExp)?.[0];
             if (!keyExpression)
                 throw new Error(`Error: keyExpression could not me extracted`);
-            if (expression !== `pk(${keyExpression})`)
-                throw new Error(`Error: invalid expression ${loggedExpression}`);
+            if (canonicalExpression !== `pk(${keyExpression})`)
+                throw new Error(`Error: invalid expression ${expression}`);
             expandedExpression = 'pk(@0)';
-            expansionMap = {
-                '@0': parseKeyExpression({ keyExpression, network, isSegwit })
-            };
-            if (!isRanged) {
-                const pubkey = expansionMap['@0'].pubkey;
+            const pKE = parseKeyExpression({ keyExpression, network, isSegwit });
+            expansionMap = { '@0': pKE };
+            if (!isCanonicalRanged) {
+                const pubkey = pKE.pubkey;
                 //Note there exists no address for p2pk, but we can still use the script
                 if (!pubkey)
-                    throw new Error(`Error: could not extract a pubkey from ${loggedExpression}`);
+                    throw new Error(`Error: could not extract a pubkey from ${expression}`);
                 payment = p2pk({ pubkey, network });
             }
         }
         //pkh(KEY) - legacy
-        else if (expression.match(RE.rePkhAnchored)) {
+        else if (canonicalExpression.match(RE.rePkhAnchored)) {
             isSegwit = false;
-            const keyExpression = expression.match(RE.reKeyExp)?.[0];
+            const keyExpression = canonicalExpression.match(RE.reKeyExp)?.[0];
             if (!keyExpression)
                 throw new Error(`Error: keyExpression could not me extracted`);
-            if (expression !== `pkh(${keyExpression})`)
-                throw new Error(`Error: invalid expression ${loggedExpression}`);
+            if (canonicalExpression !== `pkh(${keyExpression})`)
+                throw new Error(`Error: invalid expression ${expression}`);
             expandedExpression = 'pkh(@0)';
-            expansionMap = {
-                '@0': parseKeyExpression({ keyExpression, network, isSegwit })
-            };
-            if (!isRanged) {
-                const pubkey = expansionMap['@0'].pubkey;
+            const pKE = parseKeyExpression({ keyExpression, network, isSegwit });
+            expansionMap = { '@0': pKE };
+            if (!isCanonicalRanged) {
+                const pubkey = pKE.pubkey;
                 if (!pubkey)
-                    throw new Error(`Error: could not extract a pubkey from ${loggedExpression}`);
+                    throw new Error(`Error: could not extract a pubkey from ${expression}`);
                 payment = p2pkh({ pubkey, network });
             }
         }
         //sh(wpkh(KEY)) - nested segwit
-        else if (expression.match(RE.reShWpkhAnchored)) {
+        else if (canonicalExpression.match(RE.reShWpkhAnchored)) {
             isSegwit = true;
-            const keyExpression = expression.match(RE.reKeyExp)?.[0];
+            const keyExpression = canonicalExpression.match(RE.reKeyExp)?.[0];
             if (!keyExpression)
                 throw new Error(`Error: keyExpression could not me extracted`);
-            if (expression !== `sh(wpkh(${keyExpression}))`)
-                throw new Error(`Error: invalid expression ${loggedExpression}`);
+            if (canonicalExpression !== `sh(wpkh(${keyExpression}))`)
+                throw new Error(`Error: invalid expression ${expression}`);
             expandedExpression = 'sh(wpkh(@0))';
-            expansionMap = {
-                '@0': parseKeyExpression({ keyExpression, network, isSegwit })
-            };
-            if (!isRanged) {
-                const pubkey = expansionMap['@0'].pubkey;
+            const pKE = parseKeyExpression({ keyExpression, network, isSegwit });
+            expansionMap = { '@0': pKE };
+            if (!isCanonicalRanged) {
+                const pubkey = pKE.pubkey;
                 if (!pubkey)
-                    throw new Error(`Error: could not extract a pubkey from ${loggedExpression}`);
+                    throw new Error(`Error: could not extract a pubkey from ${expression}`);
                 payment = p2sh({ redeem: p2wpkh({ pubkey, network }), network });
                 redeemScript = payment.redeem?.output;
                 if (!redeemScript)
-                    throw new Error(`Error: could not calculate redeemScript for ${loggedExpression}`);
+                    throw new Error(`Error: could not calculate redeemScript for ${expression}`);
             }
         }
         //wpkh(KEY) - native segwit
-        else if (expression.match(RE.reWpkhAnchored)) {
+        else if (canonicalExpression.match(RE.reWpkhAnchored)) {
             isSegwit = true;
-            const keyExpression = expression.match(RE.reKeyExp)?.[0];
+            const keyExpression = canonicalExpression.match(RE.reKeyExp)?.[0];
             if (!keyExpression)
                 throw new Error(`Error: keyExpression could not me extracted`);
-            if (expression !== `wpkh(${keyExpression})`)
-                throw new Error(`Error: invalid expression ${loggedExpression}`);
+            if (canonicalExpression !== `wpkh(${keyExpression})`)
+                throw new Error(`Error: invalid expression ${expression}`);
             expandedExpression = 'wpkh(@0)';
-            expansionMap = {
-                '@0': parseKeyExpression({ keyExpression, network, isSegwit })
-            };
-            if (!isRanged) {
-                const pubkey = expansionMap['@0'].pubkey;
+            const pKE = parseKeyExpression({ keyExpression, network, isSegwit });
+            expansionMap = { '@0': pKE };
+            if (!isCanonicalRanged) {
+                const pubkey = pKE.pubkey;
                 if (!pubkey)
-                    throw new Error(`Error: could not extract a pubkey from ${loggedExpression}`);
+                    throw new Error(`Error: could not extract a pubkey from ${expression}`);
                 payment = p2wpkh({ pubkey, network });
             }
         }
         //sh(wsh(miniscript))
-        else if (expression.match(RE.reShWshMiniscriptAnchored)) {
+        else if (canonicalExpression.match(RE.reShWshMiniscriptAnchored)) {
             isSegwit = true;
-            miniscript = expression.match(RE.reShWshMiniscriptAnchored)?.[1]; //[1]-> whatever is found sh(wsh(->HERE<-))
+            miniscript = canonicalExpression.match(RE.reShWshMiniscriptAnchored)?.[1]; //[1]-> whatever is found sh(wsh(->HERE<-))
             if (!miniscript)
-                throw new Error(`Error: could not get miniscript in ${loggedExpression}`);
+                throw new Error(`Error: could not get miniscript in ${expression}`);
             ({ expandedMiniscript, expansionMap } = expandMiniscript({
                 miniscript,
                 isSegwit,
                 network
             }));
             expandedExpression = `sh(wsh(${expandedMiniscript}))`;
-            if (!isRanged) {
+            if (!isCanonicalRanged) {
                 const script = (0, miniscript_1.miniscript2Script)({ expandedMiniscript, expansionMap });
                 witnessScript = script;
                 if (script.byteLength > MAX_STANDARD_P2WSH_SCRIPT_SIZE) {
@@ -296,17 +303,17 @@ function DescriptorsFactory(ecc) {
                 });
                 redeemScript = payment.redeem?.output;
                 if (!redeemScript)
-                    throw new Error(`Error: could not calculate redeemScript for ${loggedExpression}`);
+                    throw new Error(`Error: could not calculate redeemScript for ${expression}`);
             }
         }
         //sh(miniscript)
-        else if (expression.match(RE.reShMiniscriptAnchored)) {
+        else if (canonicalExpression.match(RE.reShMiniscriptAnchored)) {
             //isSegwit false because we know it's a P2SH of a miniscript and not a
             //P2SH that embeds a witness payment.
             isSegwit = false;
-            miniscript = expression.match(RE.reShMiniscriptAnchored)?.[1]; //[1]-> whatever is found sh(->HERE<-)
+            miniscript = canonicalExpression.match(RE.reShMiniscriptAnchored)?.[1]; //[1]-> whatever is found sh(->HERE<-)
             if (!miniscript)
-                throw new Error(`Error: could not get miniscript in ${loggedExpression}`);
+                throw new Error(`Error: could not get miniscript in ${expression}`);
             if (allowMiniscriptInP2SH === false &&
                 //These top-level expressions within sh are allowed within sh.
                 //They can be parsed with miniscript2Script, but first we must make sure
@@ -320,7 +327,7 @@ function DescriptorsFactory(ecc) {
                 network
             }));
             expandedExpression = `sh(${expandedMiniscript})`;
-            if (!isRanged) {
+            if (!isCanonicalRanged) {
                 const script = (0, miniscript_1.miniscript2Script)({ expandedMiniscript, expansionMap });
                 redeemScript = script;
                 if (script.byteLength > MAX_SCRIPT_ELEMENT_SIZE) {
@@ -334,18 +341,18 @@ function DescriptorsFactory(ecc) {
             }
         }
         //wsh(miniscript)
-        else if (expression.match(RE.reWshMiniscriptAnchored)) {
+        else if (canonicalExpression.match(RE.reWshMiniscriptAnchored)) {
             isSegwit = true;
-            miniscript = expression.match(RE.reWshMiniscriptAnchored)?.[1]; //[1]-> whatever is found wsh(->HERE<-)
+            miniscript = canonicalExpression.match(RE.reWshMiniscriptAnchored)?.[1]; //[1]-> whatever is found wsh(->HERE<-)
             if (!miniscript)
-                throw new Error(`Error: could not get miniscript in ${loggedExpression}`);
+                throw new Error(`Error: could not get miniscript in ${expression}`);
             ({ expandedMiniscript, expansionMap } = expandMiniscript({
                 miniscript,
                 isSegwit,
                 network
             }));
             expandedExpression = `wsh(${expandedMiniscript})`;
-            if (!isRanged) {
+            if (!isCanonicalRanged) {
                 const script = (0, miniscript_1.miniscript2Script)({ expandedMiniscript, expansionMap });
                 witnessScript = script;
                 if (script.byteLength > MAX_STANDARD_P2WSH_SCRIPT_SIZE) {
@@ -359,7 +366,7 @@ function DescriptorsFactory(ecc) {
             }
         }
         else {
-            throw new Error(`Error: Could not parse descriptor ${loggedExpression}`);
+            throw new Error(`Error: Could not parse descriptor ${expression}`);
         }
         return {
             ...(payment !== undefined ? { payment } : {}),
@@ -369,7 +376,9 @@ function DescriptorsFactory(ecc) {
             ...(isSegwit !== undefined ? { isSegwit } : {}),
             ...(expandedMiniscript !== undefined ? { expandedMiniscript } : {}),
             ...(redeemScript !== undefined ? { redeemScript } : {}),
-            ...(witnessScript !== undefined ? { witnessScript } : {})
+            ...(witnessScript !== undefined ? { witnessScript } : {}),
+            isRanged,
+            canonicalExpression
         };
     };
     /**
@@ -420,19 +429,15 @@ function DescriptorsFactory(ecc) {
             __classPrivateFieldSet(this, _Descriptor_preimages, preimages, "f");
             if (typeof expression !== 'string')
                 throw new Error(`Error: invalid descriptor type`);
-            //Verify and remove checksum (if exists) and
-            //particularize range descriptor for index (if desc is range descriptor)
-            const evaluatedExpression = evaluate({
+            const expandedResult = expand({
                 expression,
                 ...(index !== undefined ? { index } : {}),
-                checksumRequired
-            });
-            const expandedResult = expand({
-                expression: evaluatedExpression,
-                loggedExpression: expression,
+                checksumRequired,
                 network,
                 allowMiniscriptInP2SH
             });
+            if (expandedResult.isRanged && index === undefined)
+                throw new Error(`Error: index was not provided for ranged descriptor`);
             if (!expandedResult.payment)
                 throw new Error(`Error: could not extract a payment from ${expression}`);
             __classPrivateFieldSet(this, _Descriptor_payment, expandedResult.payment, "f");
@@ -464,7 +469,7 @@ function DescriptorsFactory(ecc) {
                 }
                 else {
                     //We should only miss expansionMap in addr() expressions:
-                    if (!evaluatedExpression.match(RE.reAddrAnchored)) {
+                    if (!expandedResult.canonicalExpression.match(RE.reAddrAnchored)) {
                         throw new Error(`Error: expansionMap not available for expression ${expression} that is not an address`);
                     }
                     __classPrivateFieldSet(this, _Descriptor_signersPubKeys, [this.getScriptPubKey()], "f");

package/dist/index.d.ts

@@ -13,13 +13,11 @@ export declare function finalizePsbt({ psbt, descriptors, validate }: {
 export { keyExpressionBIP32, keyExpressionLedger } from './keyExpressions';
 import * as scriptExpressions from './scriptExpressions';
 export { scriptExpressions };
-import { AppClient } from 'ledger-bitcoin';
 import { LedgerState, getLedgerMasterFingerPrint, getLedgerXpub, registerLedgerWallet, assertLedgerApp } from './ledger';
 export declare const ledger: {
     getLedgerMasterFingerPrint: typeof getLedgerMasterFingerPrint;
     getLedgerXpub: typeof getLedgerXpub;
     registerLedgerWallet: typeof registerLedgerWallet;
     assertLedgerApp: typeof assertLedgerApp;
-    AppClient: typeof AppClient;
 };
 export type { LedgerState };

package/dist/index.js

@@ -42,12 +42,10 @@ Object.defineProperty(exports, "keyExpressionBIP32", { enumerable: true, get: fu
 Object.defineProperty(exports, "keyExpressionLedger", { enumerable: true, get: function () { return keyExpressions_1.keyExpressionLedger; } });
 const scriptExpressions = __importStar(require("./scriptExpressions"));
 exports.scriptExpressions = scriptExpressions;
-const ledger_bitcoin_1 = require("ledger-bitcoin");
 const ledger_1 = require("./ledger");
 exports.ledger = {
     getLedgerMasterFingerPrint: ledger_1.getLedgerMasterFingerPrint,
     getLedgerXpub: ledger_1.getLedgerXpub,
     registerLedgerWallet: ledger_1.registerLedgerWallet,
-    assertLedgerApp: ledger_1.assertLedgerApp,
-    AppClient: ledger_bitcoin_1.AppClient
+    assertLedgerApp: ledger_1.assertLedgerApp
 };

package/dist/keyExpressions.d.ts

@@ -3,7 +3,6 @@ import type { ECPairAPI } from 'ecpair';
 import type { BIP32API, BIP32Interface } from 'bip32';
 import type { KeyInfo } from './types';
 import { LedgerState } from './ledger';
-import type { AppClient } from 'ledger-bitcoin';
 export declare function parseKeyExpression({ keyExpression, isSegwit, ECPair, BIP32, network }: {
     keyExpression: string;
     network?: Network;
@@ -12,7 +11,7 @@ export declare function parseKeyExpression({ keyExpression, isSegwit, ECPair, BI
     BIP32: BIP32API;
 }): KeyInfo;
 export declare function keyExpressionLedger({ ledgerClient, ledgerState, originPath, keyPath, change, index }: {
-    ledgerClient: AppClient;
+    ledgerClient: unknown;
     ledgerState: LedgerState;
     originPath: string;
     change?: number | undefined;

package/dist/ledger.d.ts

@@ -1,6 +1,24 @@
 /// <reference types="node" />
 import type { DescriptorInterface } from './types';
-import { AppClient } from 'ledger-bitcoin';
+/**
+ * Dynamically imports the '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<any>} Returns a promise that resolves with the entire 'ledger-bitcoin' module if it can be successfully imported.
+ *
+ * @example
+ *
+ * importAndValidateLedgerBitcoin(ledgerClient)
+ *   .then((module) => {
+ *     const { AppClient, PsbtV2, DefaultWalletPolicy, WalletPolicy, DefaultDescriptorTemplate, PartialSignature } = module;
+ *     // Use the imported objects...
+ *   })
+ *   .catch((error) => console.error(error));
+ */
+export declare function importAndValidateLedgerBitcoin(ledgerClient?: unknown): Promise<typeof import("ledger-bitcoin")>;
 export declare function assertLedgerApp({ transport, name, minVersion }: {
     transport: any;
     name: string;
@@ -21,12 +39,12 @@ export type LedgerState = {
     };
 };
 export declare function getLedgerMasterFingerPrint({ ledgerClient, ledgerState }: {
-    ledgerClient: AppClient;
+    ledgerClient: unknown;
     ledgerState: LedgerState;
 }): Promise<Buffer>;
 export declare function getLedgerXpub({ originPath, ledgerClient, ledgerState }: {
     originPath: string;
-    ledgerClient: AppClient;
+    ledgerClient: unknown;
     ledgerState: LedgerState;
 }): Promise<string>;
 /**
@@ -56,7 +74,7 @@ export declare function getLedgerXpub({ originPath, ledgerClient, ledgerState }:
  */
 export declare function descriptorToLedgerFormat({ descriptor, ledgerClient, ledgerState }: {
     descriptor: DescriptorInterface;
-    ledgerClient: AppClient;
+    ledgerClient: unknown;
     ledgerState: LedgerState;
 }): Promise<{
     ledgerTemplate: string;
@@ -71,7 +89,7 @@ export declare function descriptorToLedgerFormat({ descriptor, ledgerClient, led
  **/
 export declare function registerLedgerWallet({ descriptor, ledgerClient, ledgerState, policyName }: {
     descriptor: DescriptorInterface;
-    ledgerClient: AppClient;
+    ledgerClient: unknown;
     ledgerState: LedgerState;
     policyName: string;
 }): Promise<void>;
@@ -80,7 +98,7 @@ export declare function registerLedgerWallet({ descriptor, ledgerClient, ledgerS
  **/
 export declare function ledgerPolicyFromStandard({ descriptor, ledgerClient, ledgerState }: {
     descriptor: DescriptorInterface;
-    ledgerClient: AppClient;
+    ledgerClient: unknown;
     ledgerState: LedgerState;
 }): Promise<LedgerPolicy | null>;
 export declare function comparePolicies(policyA: LedgerPolicy, policyB: LedgerPolicy): boolean;
@@ -89,6 +107,6 @@ export declare function comparePolicies(policyA: LedgerPolicy, policyB: LedgerPo
  **/
 export declare function ledgerPolicyFromState({ descriptor, ledgerClient, ledgerState }: {
     descriptor: DescriptorInterface;
-    ledgerClient: AppClient;
+    ledgerClient: unknown;
     ledgerState: LedgerState;
 }): Promise<LedgerPolicy | null>;

package/dist/ledger.js

@@ -1,11 +1,66 @@
 "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.ledgerPolicyFromState = exports.comparePolicies = exports.ledgerPolicyFromStandard = exports.registerLedgerWallet = exports.descriptorToLedgerFormat = exports.getLedgerXpub = exports.getLedgerMasterFingerPrint = exports.assertLedgerApp = void 0;
-const ledger_bitcoin_1 = require("ledger-bitcoin");
+exports.ledgerPolicyFromState = exports.comparePolicies = exports.ledgerPolicyFromStandard = exports.registerLedgerWallet = exports.descriptorToLedgerFormat = exports.getLedgerXpub = exports.getLedgerMasterFingerPrint = exports.assertLedgerApp = exports.importAndValidateLedgerBitcoin = void 0;
 const bitcoinjs_lib_1 = require("bitcoinjs-lib");
 const re_1 = require("./re");
+/**
+ * Dynamically imports the '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<any>} Returns a promise that resolves with the entire 'ledger-bitcoin' module if it can be successfully imported.
+ *
+ * @example
+ *
+ * importAndValidateLedgerBitcoin(ledgerClient)
+ *   .then((module) => {
+ *     const { AppClient, PsbtV2, DefaultWalletPolicy, WalletPolicy, DefaultDescriptorTemplate, PartialSignature } = module;
+ *     // Use the imported objects...
+ *   })
+ *   .catch((error) => console.error(error));
+ */
+async function importAndValidateLedgerBitcoin(ledgerClient) {
+    let ledgerBitcoinModule;
+    try {
+        ledgerBitcoinModule = await Promise.resolve().then(() => __importStar(require('ledger-bitcoin')));
+    }
+    catch (error) {
+        throw new Error('Could not import "ledger-bitcoin". This is a peer dependency and needs to be installed explicitly. Please run "npm install ledger-bitcoin" to use Ledger Hardware Wallet functionality.');
+    }
+    const { AppClient } = ledgerBitcoinModule;
+    if (ledgerClient !== undefined && !(ledgerClient instanceof AppClient)) {
+        throw new Error('Error: invalid AppClient instance');
+    }
+    return ledgerBitcoinModule;
+}
+exports.importAndValidateLedgerBitcoin = importAndValidateLedgerBitcoin;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 async function ledgerAppInfo(transport) {
     const r = await transport.send(0xb0, 0x01, 0x00, 0x00);
@@ -60,6 +115,9 @@ function isLedgerStandard({ ledgerTemplate, keyRoots, network = bitcoinjs_lib_1.
     return false;
 }
 async function getLedgerMasterFingerPrint({ ledgerClient, ledgerState }) {
+    const { AppClient } = await importAndValidateLedgerBitcoin(ledgerClient);
+    if (!(ledgerClient instanceof AppClient))
+        throw new Error(`Error: pass a valid ledgerClient`);
     let masterFingerprint = ledgerState.masterFingerprint;
     if (!masterFingerprint) {
         masterFingerprint = Buffer.from(await ledgerClient.getMasterFingerprint(), 'hex');
@@ -69,6 +127,9 @@ async function getLedgerMasterFingerPrint({ ledgerClient, ledgerState }) {
 }
 exports.getLedgerMasterFingerPrint = getLedgerMasterFingerPrint;
 async function getLedgerXpub({ originPath, ledgerClient, ledgerState }) {
+    const { AppClient } = await importAndValidateLedgerBitcoin(ledgerClient);
+    if (!(ledgerClient instanceof AppClient))
+        throw new Error(`Error: pass a valid ledgerClient`);
     if (!ledgerState.xpubs)
         ledgerState.xpubs = {};
     let xpub = ledgerState.xpubs[originPath];
@@ -80,6 +141,8 @@ async function getLedgerXpub({ originPath, ledgerClient, ledgerState }) {
         catch (err) {
             xpub = await ledgerClient.getExtendedPubkey(`m${originPath}`, true);
         }
+        if (typeof xpub !== 'string')
+            throw new Error(`Error: ledgerClient did not return a valid xpub`);
         ledgerState.xpubs[originPath] = xpub;
     }
     return xpub;
@@ -179,6 +242,9 @@ exports.descriptorToLedgerFormat = descriptorToLedgerFormat;
  *
  **/
 async function registerLedgerWallet({ descriptor, ledgerClient, ledgerState, policyName }) {
+    const { WalletPolicy, AppClient } = await importAndValidateLedgerBitcoin(ledgerClient);
+    if (!(ledgerClient instanceof AppClient))
+        throw new Error(`Error: pass a valid ledgerClient`);
     const result = await descriptorToLedgerFormat({
         descriptor,
         ledgerClient,
@@ -204,7 +270,7 @@ async function registerLedgerWallet({ descriptor, ledgerClient, ledgerState, pol
         //It already existed. No need to register it again.
     }
     else {
-        walletPolicy = new ledger_bitcoin_1.WalletPolicy(policyName, ledgerTemplate, keyRoots);
+        walletPolicy = new WalletPolicy(policyName, ledgerTemplate, keyRoots);
         let policyId;
         [policyId, policyHmac] = await ledgerClient.registerWallet(walletPolicy);
         const policy = {

package/dist/scriptExpressions.d.ts

@@ -1,4 +1,3 @@
-import type { AppClient } from 'ledger-bitcoin';
 import { Network } from 'bitcoinjs-lib';
 import type { LedgerState } from './ledger';
 import type { BIP32Interface } from 'bip32';
@@ -30,7 +29,7 @@ export declare const wpkhBIP32: ({ masterNode, network, keyPath, account, change
     isPublic?: boolean;
 }) => string;
 export declare const pkhLedger: ({ ledgerClient, ledgerState, network, account, keyPath, change, index }: {
-    ledgerClient: AppClient;
+    ledgerClient: unknown;
     ledgerState: LedgerState;
     network?: Network;
     account: number;
@@ -39,7 +38,7 @@ export declare const pkhLedger: ({ ledgerClient, ledgerState, network, account,
     index?: number | undefined | '*';
 }) => Promise<string>;
 export declare const shWpkhLedger: ({ ledgerClient, ledgerState, network, account, keyPath, change, index }: {
-    ledgerClient: AppClient;
+    ledgerClient: unknown;
     ledgerState: LedgerState;
     network?: Network;
     account: number;
@@ -48,7 +47,7 @@ export declare const shWpkhLedger: ({ ledgerClient, ledgerState, network, accoun
     index?: number | undefined | '*';
 }) => Promise<string>;
 export declare const wpkhLedger: ({ ledgerClient, ledgerState, network, account, keyPath, change, index }: {
-    ledgerClient: AppClient;
+    ledgerClient: unknown;
     ledgerState: LedgerState;
     network?: Network;
     account: number;

package/dist/signers.d.ts

@@ -1,7 +1,6 @@
 import type { Psbt } from 'bitcoinjs-lib';
 import type { ECPairInterface } from 'ecpair';
 import type { BIP32Interface } from 'bip32';
-import { AppClient } from 'ledger-bitcoin';
 import type { DescriptorInterface } from './types';
 import { LedgerState } from './ledger';
 export declare function signInputECPair({ psbt, index, ecpair }: {
@@ -26,12 +25,12 @@ export declare function signInputLedger({ psbt, index, descriptor, ledgerClient,
     psbt: Psbt;
     index: number;
     descriptor: DescriptorInterface;
-    ledgerClient: AppClient;
+    ledgerClient: unknown;
     ledgerState: LedgerState;
 }): Promise<void>;
 export declare function signLedger({ psbt, descriptors, ledgerClient, ledgerState }: {
     psbt: Psbt;
     descriptors: DescriptorInterface[];
-    ledgerClient: AppClient;
+    ledgerClient: unknown;
     ledgerState: LedgerState;
 }): Promise<void>;

package/dist/signers.js

@@ -3,7 +3,6 @@
 // Distributed under the MIT software license
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.signLedger = exports.signInputLedger = exports.signBIP32 = exports.signInputBIP32 = exports.signECPair = exports.signInputECPair = void 0;
-const ledger_bitcoin_1 = require("ledger-bitcoin");
 const ledger_1 = require("./ledger");
 function signInputECPair({ psbt, index, ecpair }) {
     psbt.signInput(index, ecpair);
@@ -28,6 +27,9 @@ const ledgerSignaturesForInputIndex = (index, ledgerSignatures) => ledgerSignatu
     signature: partialSignature.signature
 }));
 async function signInputLedger({ psbt, index, descriptor, ledgerClient, ledgerState }) {
+    const { PsbtV2, DefaultWalletPolicy, WalletPolicy, AppClient } = await (0, ledger_1.importAndValidateLedgerBitcoin)(ledgerClient);
+    if (!(ledgerClient instanceof AppClient))
+        throw new Error(`Error: pass a valid ledgerClient`);
     const result = await (0, ledger_1.descriptorToLedgerFormat)({
         descriptor,
         ledgerClient,
@@ -43,7 +45,7 @@ async function signInputLedger({ psbt, index, descriptor, ledgerClient, ledgerSt
         ledgerState
     });
     if (standardPolicy) {
-        ledgerSignatures = await ledgerClient.signPsbt(new ledger_bitcoin_1.PsbtV2().fromBitcoinJS(psbt), new ledger_bitcoin_1.DefaultWalletPolicy(ledgerTemplate, keyRoots[0]), null);
+        ledgerSignatures = await ledgerClient.signPsbt(new PsbtV2().fromBitcoinJS(psbt), new DefaultWalletPolicy(ledgerTemplate, keyRoots[0]), null);
     }
     else {
         const policy = await (0, ledger_1.ledgerPolicyFromState)({
@@ -53,8 +55,8 @@ async function signInputLedger({ psbt, index, descriptor, ledgerClient, ledgerSt
         });
         if (!policy || !policy.policyName || !policy.policyHmac)
             throw new Error(`Error: the descriptor's policy is not registered`);
-        const walletPolicy = new ledger_bitcoin_1.WalletPolicy(policy.policyName, ledgerTemplate, keyRoots);
-        ledgerSignatures = await ledgerClient.signPsbt(new ledger_bitcoin_1.PsbtV2().fromBitcoinJS(psbt), walletPolicy, policy.policyHmac);
+        const walletPolicy = new WalletPolicy(policy.policyName, ledgerTemplate, keyRoots);
+        ledgerSignatures = await ledgerClient.signPsbt(new PsbtV2().fromBitcoinJS(psbt), walletPolicy, policy.policyHmac);
     }
     //Add the signatures to the Psbt object using PartialSig format:
     psbt.updateInput(index, {
@@ -66,6 +68,9 @@ exports.signInputLedger = signInputLedger;
 //it clusters together wallet policy types before signing
 //it throws if it cannot sign any input.
 async function signLedger({ psbt, descriptors, ledgerClient, ledgerState }) {
+    const { PsbtV2, DefaultWalletPolicy, WalletPolicy, AppClient } = await (0, ledger_1.importAndValidateLedgerBitcoin)(ledgerClient);
+    if (!(ledgerClient instanceof AppClient))
+        throw new Error(`Error: pass a valid ledgerClient`);
     const ledgerPolicies = [];
     for (const descriptor of descriptors) {
         const policy = (await (0, ledger_1.ledgerPolicyFromState)({
@@ -95,12 +100,12 @@ async function signLedger({ psbt, descriptors, ledgerClient, ledgerState }) {
             uniquePolicy.policyHmac &&
             uniquePolicy.policyId) {
             //non-standard policy
-            const walletPolicy = new ledger_bitcoin_1.WalletPolicy(uniquePolicy.policyName, uniquePolicy.ledgerTemplate, uniquePolicy.keyRoots);
-            ledgerSignatures = await ledgerClient.signPsbt(new ledger_bitcoin_1.PsbtV2().fromBitcoinJS(psbt), walletPolicy, uniquePolicy.policyHmac);
+            const walletPolicy = new WalletPolicy(uniquePolicy.policyName, uniquePolicy.ledgerTemplate, uniquePolicy.keyRoots);
+            ledgerSignatures = await ledgerClient.signPsbt(new PsbtV2().fromBitcoinJS(psbt), walletPolicy, uniquePolicy.policyHmac);
         }
         else {
             //standard policy
-            ledgerSignatures = await ledgerClient.signPsbt(new ledger_bitcoin_1.PsbtV2().fromBitcoinJS(psbt), new ledger_bitcoin_1.DefaultWalletPolicy(uniquePolicy.ledgerTemplate, uniquePolicy.keyRoots[0]), null);
+            ledgerSignatures = await ledgerClient.signPsbt(new PsbtV2().fromBitcoinJS(psbt), new DefaultWalletPolicy(uniquePolicy.ledgerTemplate, uniquePolicy.keyRoots[0]), null);
         }
         for (const [index, ,] of ledgerSignatures) {
             psbt.updateInput(index, {

package/dist/types.d.ts

@@ -47,7 +47,8 @@ export interface ParseKeyExpression {
 export interface Expand {
     (params: {
         expression: string;
-        loggedExpression?: string;
+        index?: number;
+        checksumRequired?: boolean;
         network?: Network;
         allowMiniscriptInP2SH?: boolean;
     }): {
@@ -59,6 +60,8 @@ export interface Expand {
         expandedMiniscript?: string;
         redeemScript?: Buffer;
         witnessScript?: Buffer;
+        isRanged: boolean;
+        canonicalExpression: string;
     };
 }
 interface XOnlyPointAddTweakResult {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bitcoinerlab/descriptors",
   "homepage": "https://github.com/bitcoinerlab/descriptors",
-  "version": "0.3.0",
+  "version": "1.0.0",
   "description": "This library parses and creates Bitcoin Miniscript Descriptors and generates Partially Signed Bitcoin Transactions (PSBTs). It provides PSBT finalizers and signers for single-signature, BIP32 and Hardware Wallets.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -52,20 +52,26 @@
   "files": [
     "dist"
   ],
-  "COMMENT wrt ledger-bitcoin below": "ledger-bitcoin is installed using an alias. This package can be replaced with the official `ledger-bitcoin` npm package once [this PR](https://github.com/LedgerHQ/app-bitcoin-new/pull/147) is published to npm (likely in version > 0.2.1)",
   "dependencies": {
     "@bitcoinerlab/miniscript": "^1.2.1",
     "@bitcoinerlab/secp256k1": "^1.0.2",
     "bip32": "^3.1.0",
     "bitcoinjs-lib": "^6.1.0",
-    "ecpair": "^2.1.0",
-    "ledger-bitcoin": "npm:@bitcoinerlab/ledger@^0.2.0"
+    "ecpair": "^2.1.0"
+  },
+  "peerDependencies": {
+    "ledger-bitcoin": "^0.2.2"
+  },
+  "peerDependenciesMeta": {
+    "ledger-bitcoin": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@babel/plugin-transform-modules-commonjs": "^7.20.11",
     "@ledgerhq/hw-transport-node-hid": "^6.27.12",
-    "@typescript-eslint/eslint-plugin": "^5.53.0",
-    "@typescript-eslint/parser": "^5.53.0",
+    "@typescript-eslint/eslint-plugin": "^5.60.1",
+    "@typescript-eslint/parser": "^5.60.1",
     "babel-plugin-transform-import-meta": "^2.2.0",
     "better-docs": "^2.7.2",
     "bip39": "^3.0.4",
@@ -77,9 +83,11 @@
     "fs": "^0.0.1-security",
     "jest": "^29.4.3",
     "jsdoc": "^3.6.11",
+    "ledger-bitcoin": "^0.2.2",
     "path": "^0.12.7",
     "prettier": "^2.8.8",
     "regtest-client": "^0.2.0",
-    "ts-node-dev": "^2.0.0"
+    "ts-node-dev": "^2.0.0",
+    "typescript": "5.0"
   }
 }

package/README.draft.md

@@ -1,84 +0,0 @@
-A JavaScript library for parsing and signing Bitcoin descriptors, including those based on the Miniscript language.
-
-Key features:
-It allows signing using Hierarchical Deterministic keeps (those that use word mnemonics) and also Hardware Wallets (the Ledger wallet so far; more are comming).
-It integrates miniscript, making it super easy to program advanced transactions. For example, timelock-based vaults, multisigs vaults or inheritance are now a breeze.
-Dessigned to be used with psbt (Partially Signed Bitcion transactions) so that it can be used in mkuti-party scenarios.
-Can be used with Typescript and Javascript.
-Integrates with the bitcoinjs-lib family of modules.
-
-Usage:
-
-Installation:
-npm install @bitcoinerlab/descriptors
-
-Usage:
-
-This section describes how to use this library, starting from a very easy transaction and ends up using a smart contract that only allows spending a transaction after a certain time, providing a certain secret (a preimage) and can only be unlocked by co-signing with a Ledger wallet and a Software Wallet.
-
-We will show examples that have been run on the testnet network. We share the mnemonic we used so that you can replicate the transactions: . You won't be able to spend the transactions again but you will be able to replicate everything.
-
-```
-MNEMONIC: "drum turtle globe inherit autumn flavor slice illness sniff distance carbon elder"
-```
-
-TIP: you can use https://iancoleman.io/bip39/ to verify some of the steps below.
-
-Simple case using standard transactions:
-
-Let's start with an easy case. Let's send some sats from a Bitcoin Legacy address to a Segwit one.
-
-We are ready to use the library. Here we skip all initialization. You will be able to see the complete code on a shared repository with the tests.
-
-Examples are written using Javascript. If you want to use Typescript (recommended), please take a look to the test/integration folder for some advanced use use cases.
-Please, note that the code below is just for explanation purposes. When writting code for production you must assert all intermediate steps.
-
-```javascript
-//NETWORK is set to testnet
-const masterNode = BIP32.fromSeed(mnemonicToSeedSync(MNEMONIC), NETWORK);
-const descriptorLegacy = pkhBIP32({ masterNode, network: NETWORK, account: 0, change: 0, index: 1 });
-
-console.log(descriptorLegacy.getAddress()); //moovc1JqGrz4v6FA2U8ks8ZqjSwjv3yRKQ
-```
-
-So we sent some sats (`1679037`) to that address above. Those sats were sent in `TX_ID = "ee02b5a12c2f22e892bed376781fc9ed435f0d192a1b67ca47a7190804d8e868"`. [See it here](https://blockstream.info/testnet/tx/ee02b5a12c2f22e892bed376781fc9ed435f0d192a1b67ca47a7190804d8e868).
-
-Now let's spend them. We will send all the funds, except for a fee to our first internal address (change 1) in account 0 of the P2WPKH (Segwit) wallet:
-
-<!--https://coinfaucet.eu/en/btc-testnet/-->
-
-```javascript
-const TX_ID = "ee02b5a12c2f22e892bed376781fc9ed435f0d192a1b67ca47a7190804d8e868";
-const FEE = 100;
-
-//Define the Segwit descriptor where we will receive the sats:
-const descriptorSegwit = wpkhBIP32({ masterNode, network: NETWORK, account: 0, change: 1, index: 0 });
-
-//Get some info from the network about the Legacy utxo we will spend from:
-const txHex = await (await fetch(`https://blockstream.info/testnet/api/tx/${TX_ID}/hex`)).text();
-const txOuts = (await (await fetch(`https://blockstream.info/testnet/api/tx/${TX_ID}`)).json()).vout;
-const vout = txOuts.findIndex(txOut => txOut.scriptpubkey === descriptorLegacy.getScriptPubKey());
-const initialValue = txOut[vout].value; //1679037, as mentioned above
-
-//Create a transaction (Partially Signed Bitcoin Transaction) now:
-const psbt = new Psbt({network: NETWORK});
-//Update the transaction with the Legacy descriptor input:
-const legacyInputNumber = descriptorLegacy.updatePsbt({ psbt, vout, txHex });
-//Now add the Segwit address as the new output. Let's give some FEE to the miners
-psbt.addOutput({ address: descriptorSegwit.getAddress(), value: initialValue - FEE});
-
-//Sign the transaction, finalize it and submit it to the miners:
-signBIP32({ psbt, masterNode });
-descriptorLegacy.finalizePsbtInput({psbt, index: legacyInputNumber});
-const spendTx = psbt.extractTransaction();
-console.log(spendTx.getId()); //
-await fetch('https://blockstream.info/testnet/api/tx', {
-  method: 'POST',
-  body: spendTx.toHex()
-});
-```
-We have sent the 1679037 - 100 to ourselves in just a few lines.
-Easy! See the tx here: ....
-This has only started. Let's do really cool stuff now.
-
-