@bitcoinerlab/descriptors 2.0.3 → 2.2.0

package/README.md

@@ -84,10 +84,10 @@ To call `updatePsbtAsInput()`, use the following syntax:
 ```javascript
 import { Psbt } from 'bitcoinjs-lib';
 const psbt = new Psbt();
-const inputFinalizer = output.updatePsbtAsInput({ psbt, txHex, vout });
+const inputFinalizer = output.updatePsbtAsInput({ psbt, txHex, vout, rbf });
 ```
 
-Here, `psbt` refers to an instance of the [bitcoinjs-lib Psbt class](https://github.com/bitcoinjs/bitcoinjs-lib). The parameter `txHex` denotes a hex string that serializes the previous transaction containing this output. Meanwhile, `vout` is an integer that marks the position of the output within that transaction.
+Here, `psbt` refers to an instance of the [bitcoinjs-lib Psbt class](https://github.com/bitcoinjs/bitcoinjs-lib). The parameter `txHex` denotes a hex string that serializes the previous transaction containing this output. Meanwhile, `vout` is an integer that marks the position of the output within that transaction. Finally, `rbf` is an optional parameter (defaulting to `true`) used to indicate whether the transaction uses Replace-By-Fee (RBF). When RBF is enabled, transactions can be replaced while they are in the mempool with others that have higher fees. Note that RBF is enabled for the entire transaction if at least one input signals it. Also, note that transactions using relative time locks inherently opt into RBF due to the `nSequence` range used.
 
 The method returns the `inputFinalizer()` function. This finalizer function completes a PSBT input by adding the unlocking script (`scriptWitness` or `scriptSig`) that satisfies the previous output's spending conditions. Bear in mind that both `scriptSig` and `scriptWitness` incorporate signatures. As such, you should complete all necessary signing operations before calling `inputFinalizer()`. Detailed [explanations on the `inputFinalizer` method](#signers-and-finalizers-finalize-psbt-input) can be found in the Signers and Finalizers section.
 

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
              */
@@ -126,6 +158,7 @@ export declare function DescriptorsFactory(ecc: TinySecp256k1Interface): {
                 txId?: string;
                 value?: number;
                 vout: number;
+                rbf?: boolean;
             }): number;
             /**
              * Sets this output as an input of the provided `psbt` and updates the
@@ -144,6 +177,14 @@ export declare function DescriptorsFactory(ecc: TinySecp256k1Interface): {
              *
              * When unsure, always use `txHex`, and skip `txId` and `value` for safety.
              *
+             * Use `rbf` to mark whether this tx can be replaced with another with
+             * higher fee while being in the mempool. Note that a tx will automatically
+             * be marked as replacable if a single input requests it.
+             * Note that any transaction using a relative timelock (nSequence < 0x80000000)
+             * also falls within the RBF range (nSequence < 0xFFFFFFFE), making it
+             * inherently replaceable. So don't set `rbf` to false if this is tx uses
+             * relative time locks.
+             *
              * @returns A finalizer function to be used after signing the `psbt`.
              * This function ensures that this input is properly finalized.
              * The finalizer has this signature:
@@ -151,12 +192,13 @@ export declare function DescriptorsFactory(ecc: TinySecp256k1Interface): {
              * `( { psbt, validate = true } : { psbt: Psbt; validate: boolean | undefined } ) => void`
              *
              */
-            updatePsbtAsInput({ psbt, txHex, txId, value, vout }: {
+            updatePsbtAsInput({ psbt, txHex, txId, value, vout, rbf }: {
                 psbt: Psbt;
                 txHex?: string;
                 txId?: string;
                 value?: number;
                 vout: number;
+                rbf?: boolean;
             }): ({ psbt, validate }: {
                 psbt: Psbt;
                 /** Runs further test on the validity of the signatures.
@@ -365,8 +407,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
              */
@@ -376,6 +450,7 @@ export declare function DescriptorsFactory(ecc: TinySecp256k1Interface): {
                 txId?: string;
                 value?: number;
                 vout: number;
+                rbf?: boolean;
             }): number;
             /**
              * Sets this output as an input of the provided `psbt` and updates the
@@ -394,6 +469,14 @@ export declare function DescriptorsFactory(ecc: TinySecp256k1Interface): {
              *
              * When unsure, always use `txHex`, and skip `txId` and `value` for safety.
              *
+             * Use `rbf` to mark whether this tx can be replaced with another with
+             * higher fee while being in the mempool. Note that a tx will automatically
+             * be marked as replacable if a single input requests it.
+             * Note that any transaction using a relative timelock (nSequence < 0x80000000)
+             * also falls within the RBF range (nSequence < 0xFFFFFFFE), making it
+             * inherently replaceable. So don't set `rbf` to false if this is tx uses
+             * relative time locks.
+             *
              * @returns A finalizer function to be used after signing the `psbt`.
              * This function ensures that this input is properly finalized.
              * The finalizer has this signature:
@@ -401,12 +484,13 @@ export declare function DescriptorsFactory(ecc: TinySecp256k1Interface): {
              * `( { psbt, validate = true } : { psbt: Psbt; validate: boolean | undefined } ) => void`
              *
              */
-            updatePsbtAsInput({ psbt, txHex, txId, value, vout }: {
+            updatePsbtAsInput({ psbt, txHex, txId, value, vout, rbf }: {
                 psbt: Psbt;
                 txHex?: string;
                 txId?: string;
                 value?: number;
                 vout: number;
+                rbf?: boolean;
             }): ({ psbt, validate }: {
                 psbt: Psbt;
                 /** Runs further test on the validity of the signatures.

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
          */
@@ -635,6 +905,14 @@ function DescriptorsFactory(ecc) {
          *
          * When unsure, always use `txHex`, and skip `txId` and `value` for safety.
          *
+         * Use `rbf` to mark whether this tx can be replaced with another with
+         * higher fee while being in the mempool. Note that a tx will automatically
+         * be marked as replacable if a single input requests it.
+         * Note that any transaction using a relative timelock (nSequence < 0x80000000)
+         * also falls within the RBF range (nSequence < 0xFFFFFFFE), making it
+         * inherently replaceable. So don't set `rbf` to false if this is tx uses
+         * relative time locks.
+         *
          * @returns A finalizer function to be used after signing the `psbt`.
          * This function ensures that this input is properly finalized.
          * The finalizer has this signature:
@@ -642,8 +920,8 @@ function DescriptorsFactory(ecc) {
          * `( { psbt, validate = true } : { psbt: Psbt; validate: boolean | undefined } ) => void`
          *
          */
-        updatePsbtAsInput({ psbt, txHex, txId, value, vout //vector output index
-         }) {
+        updatePsbtAsInput({ psbt, txHex, txId, value, vout, //vector output index
+        rbf = true }) {
             if (txHex === undefined) {
                 console.warn(`Warning: missing txHex may allow fee attacks`);
             }
@@ -664,7 +942,8 @@ function DescriptorsFactory(ecc) {
                 scriptPubKey: this.getScriptPubKey(),
                 isSegwit,
                 witnessScript: this.getWitnessScript(),
-                redeemScript: this.getRedeemScript()
+                redeemScript: this.getRedeemScript(),
+                rbf
             });
             const finalizer = ({ psbt, validate = true }) => this.finalizePsbtInput({ index, psbt, validate });
             return finalizer;
@@ -802,16 +1081,20 @@ function DescriptorsFactory(ecc) {
             scriptPubKey = out.script;
         }
         const locktime = this.getLockTime() || 0;
-        let sequence = this.getSequence();
-        if (sequence === undefined && locktime !== 0)
-            sequence = 0xfffffffe;
-        if (sequence === undefined && locktime === 0)
-            sequence = 0xffffffff;
+        const sequence = this.getSequence();
+        //We don't know whether the user opted for RBF or not. So check that
+        //at least one of the 2 sequences matches.
+        const sequenceNoRBF = sequence !== undefined
+            ? sequence
+            : locktime === 0
+                ? 0xffffffff
+                : 0xfffffffe;
+        const sequenceRBF = sequence !== undefined ? sequence : 0xfffffffd;
         const eqBuffers = (buf1, buf2) => buf1 instanceof Buffer && buf2 instanceof Buffer
             ? Buffer.compare(buf1, buf2) === 0
             : buf1 === buf2;
         if (Buffer.compare(scriptPubKey, this.getScriptPubKey()) !== 0 ||
-            sequence !== inputSequence ||
+            (sequenceRBF !== inputSequence && sequenceNoRBF !== inputSequence) ||
             locktime !== psbt.locktime ||
             !eqBuffers(this.getWitnessScript(), input.witnessScript) ||
             !eqBuffers(this.getRedeemScript(), input.redeemScript)) {

package/dist/psbt.d.ts

@@ -21,7 +21,7 @@ export declare function finalScriptsFuncFactory(scriptSatisfaction: Buffer, netw
 /**
  * Important: Read comments on descriptor.updatePsbt regarding not passing txHex
  */
-export declare function updatePsbt({ psbt, vout, txHex, txId, value, sequence, locktime, keysInfo, scriptPubKey, isSegwit, witnessScript, redeemScript }: {
+export declare function updatePsbt({ psbt, vout, txHex, txId, value, sequence, locktime, keysInfo, scriptPubKey, isSegwit, witnessScript, redeemScript, rbf }: {
     psbt: Psbt;
     vout: number;
     txHex?: string;
@@ -34,5 +34,6 @@ export declare function updatePsbt({ psbt, vout, txHex, txId, value, sequence, l
     isSegwit: boolean;
     witnessScript: Buffer | undefined;
     redeemScript: Buffer | undefined;
+    rbf: boolean;
 }): number;
 export {};

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);
@@ -109,8 +86,10 @@ exports.finalScriptsFuncFactory = finalScriptsFuncFactory;
 /**
  * Important: Read comments on descriptor.updatePsbt regarding not passing txHex
  */
-function updatePsbt({ psbt, vout, txHex, txId, value, sequence, locktime, keysInfo, scriptPubKey, isSegwit, witnessScript, redeemScript }) {
+function updatePsbt({ psbt, vout, txHex, txId, value, sequence, locktime, keysInfo, scriptPubKey, isSegwit, witnessScript, redeemScript, rbf }) {
     //Some data-sanity checks:
+    if (sequence !== undefined && rbf && sequence > 0xfffffffd)
+        throw new Error(`Error: incompatible sequence and rbf settings`);
     if (!isSegwit && txHex === undefined)
         throw new Error(`Error: txHex is mandatory for Non-Segwit inputs`);
     if (isSegwit &&
@@ -152,13 +131,23 @@ function updatePsbt({ psbt, vout, txHex, txId, value, sequence, locktime, keysIn
         // this input's sequence < 0xffffffff
         if (sequence === undefined) {
             //NOTE: if sequence is undefined, bitcoinjs-lib uses 0xffffffff as default
-            sequence = 0xfffffffe;
+            sequence = rbf ? 0xfffffffd : 0xfffffffe;
         }
         else if (sequence > 0xfffffffe) {
             throw new Error(`Error: incompatible sequence: ${sequence} and locktime: ${locktime}`);
         }
+        if (sequence === undefined && rbf)
+            sequence = 0xfffffffd;
         psbt.setLocktime(locktime);
     }
+    else {
+        if (sequence === undefined) {
+            if (rbf)
+                sequence = 0xfffffffd;
+            else
+                sequence = 0xffffffff;
+        }
+    }
     const input = {
         hash: reverseBuffer(Buffer.from(txId, 'hex')),
         index: vout

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.2.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",
@@ -66,10 +67,12 @@
     "yargs": "^17.7.2"
   },
   "dependencies": {
-    "@bitcoinerlab/miniscript": "^1.2.1",
-    "@bitcoinerlab/secp256k1": "^1.0.5",
+    "@bitcoinerlab/miniscript": "^1.4.0",
+    "@bitcoinerlab/secp256k1": "^1.1.1",
     "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"
   }
 }