@bitcoinerlab/descriptors 2.0.3 → 2.1.0

package/dist/descriptors.d.ts

@@ -115,8 +115,40 @@ export declare function DescriptorsFactory(ecc: TinySecp256k1Interface): {
             getNetwork(): Network;
             /**
              * Whether this `Output` is Segwit.
+             *
+             * *NOTE:* When the descriptor in an input is `addr(address)`, it is assumed
+             * that any `addr(SH_TYPE_ADDRESS)` is in fact a Segwit `SH_WPKH`
+             * (Script Hash-Witness Public Key Hash).
+             * For inputs using arbitrary scripts (not standard addresses),
+             * use a descriptor in the format `sh(MINISCRIPT)`.
+             *
              */
             isSegwit(): boolean | undefined;
+            /**
+             * Returns the tuple: `{ isPKH: boolean; isWPKH: boolean; isSH: boolean; }`
+             * for this Output.
+             */
+            guessOutput(): {
+                isPKH: boolean;
+                isWPKH: boolean;
+                isSH: boolean;
+            };
+            /**
+             * Computes the Weight Unit contributions of this Output as if it were the
+             * input in a tx.
+             *
+             * *NOTE:* When the descriptor in an input is `addr(address)`, it is assumed
+             * that any `addr(SH_TYPE_ADDRESS)` is in fact a Segwit `SH_WPKH`
+             * (Script Hash-Witness Public Key Hash).
+             * For inputs using arbitrary scripts (not standard addresses),
+             * use a descriptor in the format `sh(MINISCRIPT)`.
+             */
+            inputWeight(isSegwitTx: boolean, signatures: PartialSig[] | 'DANGEROUSLY_USE_FAKE_SIGNATURES'): number;
+            /**
+             * Computes the Weight Unit contributions of this Output as if it were the
+             * output in a tx.
+             */
+            outputWeight(): number;
             /** @deprecated - Use updatePsbtAsInput instead
              * @hidden
              */
@@ -365,8 +397,40 @@ export declare function DescriptorsFactory(ecc: TinySecp256k1Interface): {
             getNetwork(): Network;
             /**
              * Whether this `Output` is Segwit.
+             *
+             * *NOTE:* When the descriptor in an input is `addr(address)`, it is assumed
+             * that any `addr(SH_TYPE_ADDRESS)` is in fact a Segwit `SH_WPKH`
+             * (Script Hash-Witness Public Key Hash).
+             * For inputs using arbitrary scripts (not standard addresses),
+             * use a descriptor in the format `sh(MINISCRIPT)`.
+             *
              */
             isSegwit(): boolean | undefined;
+            /**
+             * Returns the tuple: `{ isPKH: boolean; isWPKH: boolean; isSH: boolean; }`
+             * for this Output.
+             */
+            guessOutput(): {
+                isPKH: boolean;
+                isWPKH: boolean;
+                isSH: boolean;
+            };
+            /**
+             * Computes the Weight Unit contributions of this Output as if it were the
+             * input in a tx.
+             *
+             * *NOTE:* When the descriptor in an input is `addr(address)`, it is assumed
+             * that any `addr(SH_TYPE_ADDRESS)` is in fact a Segwit `SH_WPKH`
+             * (Script Hash-Witness Public Key Hash).
+             * For inputs using arbitrary scripts (not standard addresses),
+             * use a descriptor in the format `sh(MINISCRIPT)`.
+             */
+            inputWeight(isSegwitTx: boolean, signatures: PartialSig[] | 'DANGEROUSLY_USE_FAKE_SIGNATURES'): number;
+            /**
+             * Computes the Weight Unit contributions of this Output as if it were the
+             * output in a tx.
+             */
+            outputWeight(): number;
             /** @deprecated - Use updatePsbtAsInput instead
              * @hidden
              */

package/dist/descriptors.js

@@ -35,9 +35,14 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DescriptorsFactory = void 0;
+const lodash_memoize_1 = __importDefault(require("lodash.memoize"));
 const bitcoinjs_lib_1 = require("bitcoinjs-lib");
+const varuint_bitcoin_1 = require("varuint-bitcoin");
 const { p2sh, p2wpkh, p2pkh, p2pk, p2wsh, p2tr } = bitcoinjs_lib_1.payments;
 const bip32_1 = require("bip32");
 const ecpair_1 = require("ecpair");
@@ -57,6 +62,28 @@ function countNonPushOnlyOPs(script) {
         throw new Error(`Error: cound not decompile ${script}`);
     return decompile.filter(op => typeof op === 'number' && op > bitcoinjs_lib_1.script.OPS['OP_16']).length;
 }
+function vectorSize(someVector) {
+    const length = someVector.length;
+    return ((0, varuint_bitcoin_1.encodingLength)(length) +
+        someVector.reduce((sum, witness) => {
+            return sum + varSliceSize(witness);
+        }, 0));
+}
+function varSliceSize(someScript) {
+    const length = someScript.length;
+    return (0, varuint_bitcoin_1.encodingLength)(length) + length;
+}
+/**
+ * This function will typically return 73; since it assumes a signature size of
+ * 72 bytes (this is the max size of a DER encoded signature) and it adds 1
+ * extra byte for encoding its length
+ */
+function signatureSize(signature) {
+    const length = signature === 'DANGEROUSLY_USE_FAKE_SIGNATURES'
+        ? 72
+        : signature.signature.length;
+    return (0, varuint_bitcoin_1.encodingLength)(length) + length;
+}
 /*
  * Returns a bare descriptor without checksum and particularized for a certain
  * index (if desc was a range descriptor)
@@ -184,22 +211,28 @@ function DescriptorsFactory(ecc) {
             }
             try {
                 payment = p2pkh({ output, network });
+                isSegwit = false;
             }
             catch (e) { }
             try {
                 payment = p2sh({ output, network });
+                // It assumes that an addr(SH_ADDRESS) is always a add(SH_WPKH) address
+                isSegwit = true;
             }
             catch (e) { }
             try {
                 payment = p2wpkh({ output, network });
+                isSegwit = true;
             }
             catch (e) { }
             try {
                 payment = p2wsh({ output, network });
+                isSegwit = true;
             }
             catch (e) { }
             try {
                 payment = p2tr({ output, network });
+                isSegwit = true;
             }
             catch (e) { }
             if (!payment) {
@@ -480,6 +513,25 @@ function DescriptorsFactory(ecc) {
                     __classPrivateFieldSet(this, _Output_signersPubKeys, [this.getScriptPubKey()], "f");
                 }
             }
+            this.getSequence = (0, lodash_memoize_1.default)(this.getSequence);
+            this.getLockTime = (0, lodash_memoize_1.default)(this.getLockTime);
+            const getSignaturesKey = (signatures) => signatures === 'DANGEROUSLY_USE_FAKE_SIGNATURES'
+                ? signatures
+                : signatures
+                    .map(s => `${s.pubkey.toString('hex')}-${s.signature.toString('hex')}`)
+                    .join('|');
+            this.getScriptSatisfaction = (0, lodash_memoize_1.default)(this.getScriptSatisfaction, 
+            // resolver function:
+            getSignaturesKey);
+            this.guessOutput = (0, lodash_memoize_1.default)(this.guessOutput);
+            this.inputWeight = (0, lodash_memoize_1.default)(this.inputWeight, 
+            // resolver function:
+            (isSegwitTx, signatures) => {
+                const segwitKey = isSegwitTx ? 'segwit' : 'non-segwit';
+                const signaturesKey = getSignaturesKey(signatures);
+                return `${segwitKey}-${signaturesKey}`;
+            });
+            this.outputWeight = (0, lodash_memoize_1.default)(this.outputWeight);
         }
         /**
          * Creates and returns an instance of bitcoinjs-lib
@@ -607,10 +659,228 @@ function DescriptorsFactory(ecc) {
         }
         /**
          * Whether this `Output` is Segwit.
+         *
+         * *NOTE:* When the descriptor in an input is `addr(address)`, it is assumed
+         * that any `addr(SH_TYPE_ADDRESS)` is in fact a Segwit `SH_WPKH`
+         * (Script Hash-Witness Public Key Hash).
+         * For inputs using arbitrary scripts (not standard addresses),
+         * use a descriptor in the format `sh(MINISCRIPT)`.
+         *
          */
         isSegwit() {
             return __classPrivateFieldGet(this, _Output_isSegwit, "f");
         }
+        /**
+         * Returns the tuple: `{ isPKH: boolean; isWPKH: boolean; isSH: boolean; }`
+         * for this Output.
+         */
+        guessOutput() {
+            function guessSH(output) {
+                try {
+                    bitcoinjs_lib_1.payments.p2sh({ output });
+                    return true;
+                }
+                catch (err) {
+                    return false;
+                }
+            }
+            function guessWPKH(output) {
+                try {
+                    bitcoinjs_lib_1.payments.p2wpkh({ output });
+                    return true;
+                }
+                catch (err) {
+                    return false;
+                }
+            }
+            function guessPKH(output) {
+                try {
+                    bitcoinjs_lib_1.payments.p2pkh({ output });
+                    return true;
+                }
+                catch (err) {
+                    return false;
+                }
+            }
+            const isPKH = guessPKH(this.getScriptPubKey());
+            const isWPKH = guessWPKH(this.getScriptPubKey());
+            const isSH = guessSH(this.getScriptPubKey());
+            if ([isPKH, isWPKH, isSH].filter(Boolean).length > 1)
+                throw new Error('Cannot have multiple output types.');
+            return { isPKH, isWPKH, isSH };
+        }
+        // References for inputWeight & outputWeight:
+        // https://gist.github.com/junderw/b43af3253ea5865ed52cb51c200ac19c
+        // https://bitcoinops.org/en/tools/calc-size/
+        // Look for byteLength: https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/ts_src/transaction.ts
+        // https://github.com/bitcoinjs/coinselect/blob/master/utils.js
+        /**
+         * Computes the Weight Unit contributions of this Output as if it were the
+         * input in a tx.
+         *
+         * *NOTE:* When the descriptor in an input is `addr(address)`, it is assumed
+         * that any `addr(SH_TYPE_ADDRESS)` is in fact a Segwit `SH_WPKH`
+         * (Script Hash-Witness Public Key Hash).
+         * For inputs using arbitrary scripts (not standard addresses),
+         * use a descriptor in the format `sh(MINISCRIPT)`.
+         */
+        inputWeight(
+        /**
+         * Indicates if the transaction is a Segwit transaction.
+         * If a transaction isSegwitTx, a single byte is then also required for
+         * non-witness inputs to encode the length of the empty witness stack:
+         * encodeLength(0) + 0 = 1
+         * Read more:
+         * https://gist.github.com/junderw/b43af3253ea5865ed52cb51c200ac19c?permalink_comment_id=4760512#gistcomment-4760512
+         */
+        isSegwitTx, 
+        /*
+         *  Array of `PartialSig`. Each `PartialSig` includes
+         *  a public key and its corresponding signature. This parameter
+         *  enables the accurate calculation of signature sizes.
+         *  Pass 'DANGEROUSLY_USE_FAKE_SIGNATURES' to assume 72 bytes in length.
+         *  Mainly used for testing.
+         */
+        signatures) {
+            if (this.isSegwit() && !isSegwitTx)
+                throw new Error(`a tx is segwit if at least one input is segwit`);
+            const errorMsg = 'Input type not implemented. Currently supported: pkh(KEY), wpkh(KEY), \
+    sh(wpkh(KEY)), sh(wsh(MINISCRIPT)), sh(MINISCRIPT), wsh(MINISCRIPT), \
+    addr(PKH_ADDRESS), addr(WPKH_ADDRESS), addr(SH_WPKH_ADDRESS).';
+            //expand any miniscript-based descriptor. If not miniscript-based, then it's
+            //an addr() descriptor. For those, we can only guess their type.
+            const expansion = this.expand().expandedExpression;
+            const { isPKH, isWPKH, isSH } = this.guessOutput();
+            if (!expansion && !isPKH && !isWPKH && !isSH)
+                throw new Error(errorMsg);
+            const firstSignature = signatures && typeof signatures[0] === 'object'
+                ? signatures[0]
+                : 'DANGEROUSLY_USE_FAKE_SIGNATURES';
+            if (expansion ? expansion.startsWith('pkh(') : isPKH) {
+                return (
+                // Non-segwit: (txid:32) + (vout:4) + (sequence:4) + (script_len:1) + (sig:73) + (pubkey:34)
+                (32 + 4 + 4 + 1 + signatureSize(firstSignature) + 34) * 4 +
+                    //Segwit:
+                    (isSegwitTx ? 1 : 0));
+            }
+            else if (expansion ? expansion.startsWith('wpkh(') : isWPKH) {
+                if (!isSegwitTx)
+                    throw new Error('Should be SegwitTx');
+                return (
+                // Non-segwit: (txid:32) + (vout:4) + (sequence:4) + (script_len:1)
+                41 * 4 +
+                    // Segwit: (push_count:1) + (sig:73) + (pubkey:34)
+                    (1 + signatureSize(firstSignature) + 34));
+            }
+            else if (expansion ? expansion.startsWith('sh(wpkh(') : isSH) {
+                if (!isSegwitTx)
+                    throw new Error('Should be SegwitTx');
+                return (
+                // Non-segwit: (txid:32) + (vout:4) + (sequence:4) + (script_len:1) + (p2wpkh:23)
+                //  -> p2wpkh_script: OP_0 OP_PUSH20 <public_key_hash>
+                //  -> p2wpkh: (script_len:1) + (script:22)
+                64 * 4 +
+                    // Segwit: (push_count:1) + (sig:73) + (pubkey:34)
+                    (1 + signatureSize(firstSignature) + 34));
+            }
+            else if (expansion?.startsWith('sh(wsh(')) {
+                if (!isSegwitTx)
+                    throw new Error('Should be SegwitTx');
+                const witnessScript = this.getWitnessScript();
+                if (!witnessScript)
+                    throw new Error('sh(wsh) must provide witnessScript');
+                const payment = bitcoinjs_lib_1.payments.p2sh({
+                    redeem: bitcoinjs_lib_1.payments.p2wsh({
+                        redeem: {
+                            input: this.getScriptSatisfaction(signatures || 'DANGEROUSLY_USE_FAKE_SIGNATURES'),
+                            output: witnessScript
+                        }
+                    })
+                });
+                if (!payment || !payment.input || !payment.witness)
+                    throw new Error('Could not create payment');
+                return (
+                //Non-segwit
+                4 * (40 + varSliceSize(payment.input)) +
+                    //Segwit
+                    vectorSize(payment.witness));
+            }
+            else if (expansion?.startsWith('sh(')) {
+                const redeemScript = this.getRedeemScript();
+                if (!redeemScript)
+                    throw new Error('sh() must provide redeemScript');
+                const payment = bitcoinjs_lib_1.payments.p2sh({
+                    redeem: {
+                        input: this.getScriptSatisfaction(signatures || 'DANGEROUSLY_USE_FAKE_SIGNATURES'),
+                        output: redeemScript
+                    }
+                });
+                if (!payment || !payment.input)
+                    throw new Error('Could not create payment');
+                if (payment.witness?.length)
+                    throw new Error('A legacy p2sh payment should not cointain a witness');
+                return (
+                //Non-segwit
+                4 * (40 + varSliceSize(payment.input)) +
+                    //Segwit:
+                    (isSegwitTx ? 1 : 0));
+            }
+            else if (expansion?.startsWith('wsh(')) {
+                const witnessScript = this.getWitnessScript();
+                if (!witnessScript)
+                    throw new Error('wsh must provide witnessScript');
+                const payment = bitcoinjs_lib_1.payments.p2wsh({
+                    redeem: {
+                        input: this.getScriptSatisfaction(signatures || 'DANGEROUSLY_USE_FAKE_SIGNATURES'),
+                        output: witnessScript
+                    }
+                });
+                if (!payment || !payment.input || !payment.witness)
+                    throw new Error('Could not create payment');
+                return (
+                //Non-segwit
+                4 * (40 + varSliceSize(payment.input)) +
+                    //Segwit
+                    vectorSize(payment.witness));
+            }
+            else {
+                throw new Error(errorMsg);
+            }
+        }
+        /**
+         * Computes the Weight Unit contributions of this Output as if it were the
+         * output in a tx.
+         */
+        outputWeight() {
+            const errorMsg = 'Output type not implemented. Currently supported: pkh(KEY), wpkh(KEY), \
+    sh(ANYTHING), wsh(ANYTHING), addr(PKH_ADDRESS), addr(WPKH_ADDRESS), \
+    addr(SH_WPKH_ADDRESS)';
+            //expand any miniscript-based descriptor. If not miniscript-based, then it's
+            //an addr() descriptor. For those, we can only guess their type.
+            const expansion = this.expand().expandedExpression;
+            const { isPKH, isWPKH, isSH } = this.guessOutput();
+            if (!expansion && !isPKH && !isWPKH && !isSH)
+                throw new Error(errorMsg);
+            if (expansion ? expansion.startsWith('pkh(') : isPKH) {
+                // (p2pkh:26) + (amount:8)
+                return 34 * 4;
+            }
+            else if (expansion ? expansion.startsWith('wpkh(') : isWPKH) {
+                // (p2wpkh:23) + (amount:8)
+                return 31 * 4;
+            }
+            else if (expansion ? expansion.startsWith('sh(') : isSH) {
+                // (p2sh:24) + (amount:8)
+                return 32 * 4;
+            }
+            else if (expansion?.startsWith('wsh(')) {
+                // (p2wsh:35) + (amount:8)
+                return 43 * 4;
+            }
+            else {
+                throw new Error(errorMsg);
+            }
+        }
         /** @deprecated - Use updatePsbtAsInput instead
          * @hidden
          */

package/dist/psbt.js

@@ -1,33 +1,10 @@
 "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.updatePsbt = exports.finalScriptsFuncFactory = void 0;
 const bitcoinjs_lib_1 = require("bitcoinjs-lib");
-const varuint = __importStar(require("bip174/src/lib/converter/varint"));
+const varuint_bitcoin_1 = require("varuint-bitcoin");
 function reverseBuffer(buffer) {
     if (buffer.length < 1)
         return buffer;
@@ -48,9 +25,9 @@ function witnessStackToScriptWitness(witness) {
     }
     function writeVarInt(i) {
         const currentLen = buffer.length;
-        const varintLen = varuint.encodingLength(i);
+        const varintLen = (0, varuint_bitcoin_1.encodingLength)(i);
         buffer = Buffer.concat([buffer, Buffer.allocUnsafe(varintLen)]);
-        varuint.encode(i, buffer, currentLen);
+        (0, varuint_bitcoin_1.encode)(i, buffer, currentLen);
     }
     function writeVarSlice(slice) {
         writeVarInt(slice.length);

package/package.json

@@ -2,7 +2,7 @@
   "name": "@bitcoinerlab/descriptors",
   "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.",
   "homepage": "https://github.com/bitcoinerlab/descriptors",
-  "version": "2.0.3",
+  "version": "2.1.0",
   "author": "Jose-Luis Landabaso",
   "license": "MIT",
   "repository": {
@@ -32,7 +32,7 @@
     "docs": "typedoc --options ./node_modules/@bitcoinerlab/configs/typedoc.json",
     "build:src": "tsc --project ./node_modules/@bitcoinerlab/configs/tsconfig.src.json",
     "build:fixtures": "node test/tools/generateBitcoinCoreFixtures.js -i test/fixtures/descriptor_tests.cpp | npx prettier --parser typescript > test/fixtures/bitcoinCore.ts",
-    "build:test": "npm run build:fixtures && tsc --project ./node_modules/@bitcoinerlab/configs/tsconfig.test.json",
+    "build:test": "npm run build:fixtures && tsc --project ./node_modules/@bitcoinerlab/configs/tsconfig.test.json --resolveJsonModule",
     "build": "npm run build:src && npm run build:test",
     "lint": "eslint --ignore-path .gitignore --ext .ts src/ test/",
     "ensureTester": "./node_modules/@bitcoinerlab/configs/scripts/ensureTester.sh",
@@ -58,6 +58,7 @@
   "devDependencies": {
     "@bitcoinerlab/configs": "github:bitcoinerlab/configs",
     "@ledgerhq/hw-transport-node-hid": "^6.27.12",
+    "@types/lodash.memoize": "^4.1.9",
     "bip39": "^3.0.4",
     "bip65": "^1.0.3",
     "bip68": "^1.0.4",
@@ -70,6 +71,8 @@
     "@bitcoinerlab/secp256k1": "^1.0.5",
     "bip32": "^4.0.0",
     "bitcoinjs-lib": "^6.1.3",
-    "ecpair": "^2.1.0"
+    "ecpair": "^2.1.0",
+    "lodash.memoize": "^4.1.2",
+    "varuint-bitcoin": "^1.1.2"
   }
 }