@bitcoinerlab/descriptors 0.2.0

package/dist/miniscript.d.ts

@@ -0,0 +1,109 @@
+/// <reference types="node" />
+import { Network } from 'bitcoinjs-lib';
+import type { ECPairAPI } from 'ecpair';
+import type { BIP32API } from 'bip32';
+import type { PartialSig } from 'bip174/src/lib/interfaces';
+import type { Preimage, TimeConstraints, ExpansionMap } from './types';
+/**
+ * Expand a miniscript to a generalized form using variables instead of key
+ * expressions. Variables will be of this form: @0, @1, ...
+ * This is done so that it can be compiled with compileMiniscript and
+ * satisfied with satisfier.
+ * Also compute pubkeys from descriptors to use them later.
+ */
+export declare function expandMiniscript({ miniscript, isSegwit, network, ECPair, BIP32 }: {
+    miniscript: string;
+    isSegwit: boolean;
+    network?: Network;
+    ECPair: ECPairAPI;
+    BIP32: BIP32API;
+}): {
+    expandedMiniscript: string;
+    expansionMap: ExpansionMap;
+};
+export declare function miniscript2Script({ expandedMiniscript, expansionMap }: {
+    expandedMiniscript: string;
+    expansionMap: ExpansionMap;
+}): Buffer;
+/**
+ * Assumptions:
+ * The attacker does not have access to any of the private keys of public keys
+ * that participate in the Script.
+ *
+ * The attacker only has access to hash preimages that honest users have access
+ * to as well.
+ *
+ * Pass timeConstraints to search for the first solution with this nLockTime and
+ * nSequence. Throw if no solution is possible using these constraints.
+ *
+ * Don't pass timeConstraints (this is the default) if you want to get the
+ * smallest size solution altogether.
+ *
+ * If a solution is not found this function throws.
+ */
+export declare function satisfyMiniscript({ expandedMiniscript, expansionMap, signatures, preimages, timeConstraints }: {
+    expandedMiniscript: string;
+    expansionMap: ExpansionMap;
+    signatures?: PartialSig[];
+    preimages?: Preimage[];
+    timeConstraints?: TimeConstraints;
+}): {
+    scriptSatisfaction: Buffer;
+    nLockTime: number | undefined;
+    nSequence: number | undefined;
+};
+/**
+ *
+ * Use this function instead of bitcoinjs-lib's equivalent `script.number.encode`
+ * when encoding numbers to be compiled with `fromASM` to avoid problems.
+ *
+ * Motivation:
+ *
+ * Numbers in Bitcoin assembly code are represented in hex and in Little Endian.
+ * Decimal: 32766 - Big endian: 0x7FFE - Little Endian: 0xFE7F.
+ *
+ * This function takes an integer and encodes it so that bitcoinjs-lib `fromASM`
+ * can compile it. This is basically what bitcoinjs-lib's `script.number.encode`
+ * does.
+ *
+ * Note that `fromASM` already converts integers from 1 to 16 to
+ * OP_1 ... OP_16 {@link https://github.com/bitcoinjs/bitcoinjs-lib/blob/59b21162a2c4645c64271ca004c7a3755a3d72fb/src/script.js#L33 here}.
+ * This is done in Bitcoin to save some bits.
+ *
+ * Neither this function nor `script.number.encode` convert numbers to
+ * their op code equivalent since this is done later in `fromASM`.
+ *
+ * Both functions simply convert numbers to Little Endian.
+ *
+ * However, the `0` number is an edge case that we specially handle with this
+ * function.
+ *
+ * bitcoinjs-lib's `bscript.number.encode(0)` produces an empty Buffer.
+ * This is what the Bitcoin interpreter does and it is what `script.number.encode` was
+ * implemented to do.
+ *
+ * The problem is `bscript.number.encode(0).toString('hex')` produces an
+ * empty string and thus it should not be used to serialize number zero before `fromASM`.
+ *
+ * A zero should produce the OP_0 ASM symbolic code (corresponding to a `0` when
+ * compiled).
+ *
+ * So, this function will produce a string in hex format in Little Endian
+ * encoding for integers not equal to `0` and it will return `OP_0` for `0`.
+ *
+ * Read more about the this {@link https://github.com/bitcoinjs/bitcoinjs-lib/issues/1799#issuecomment-1122591738 here}.
+ *
+ * Use it in combination with `fromASM` like this:
+ *
+ * ```javascript
+ * //To produce "0 1 OP_ADD":
+ * fromASM(
+ * `${numberEncodeAsm(0)} ${numberEncodeAsm(1)} OP_ADD`
+ *   .trim().replace(/\s+/g, ' ')
+ * )
+ * ```
+ *
+ * @param {number} number An integer.
+ * @returns {string} Returns `"OP_0"` for `number === 0` and a hex string representing other numbers in Little Endian encoding.
+ */
+export declare function numberEncodeAsm(number: number): string;

package/dist/miniscript.js

@@ -0,0 +1,239 @@
+"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.numberEncodeAsm = exports.satisfyMiniscript = exports.miniscript2Script = exports.expandMiniscript = void 0;
+const bitcoinjs_lib_1 = require("bitcoinjs-lib");
+const keyExpressions_1 = require("./keyExpressions");
+const RE = __importStar(require("./re"));
+const miniscript_1 = require("@bitcoinerlab/miniscript");
+/**
+ * Expand a miniscript to a generalized form using variables instead of key
+ * expressions. Variables will be of this form: @0, @1, ...
+ * This is done so that it can be compiled with compileMiniscript and
+ * satisfied with satisfier.
+ * Also compute pubkeys from descriptors to use them later.
+ */
+function expandMiniscript({ miniscript, isSegwit, network = bitcoinjs_lib_1.networks.bitcoin, ECPair, BIP32 }) {
+    const expansionMap = {};
+    const expandedMiniscript = miniscript.replace(RegExp(RE.reKeyExp, 'g'), (keyExpression) => {
+        const key = '@' + Object.keys(expansionMap).length;
+        expansionMap[key] = (0, keyExpressions_1.parseKeyExpression)({
+            keyExpression,
+            isSegwit,
+            network,
+            ECPair,
+            BIP32
+        });
+        return key;
+    });
+    //Do some assertions. Miniscript must not have duplicate keys, also all
+    //keyExpressions must produce a valid pubkey
+    const pubkeysHex = Object.values(expansionMap).map(keyInfo => {
+        if (!keyInfo.pubkey)
+            throw new Error(`Error: keyExpression ${keyInfo.keyExpression} does not have a pubkey`);
+        return keyInfo.pubkey.toString('hex');
+    });
+    if (new Set(pubkeysHex).size !== pubkeysHex.length) {
+        throw new Error(`Error: miniscript ${miniscript} is not sane: contains duplicate public keys.`);
+    }
+    return { expandedMiniscript, expansionMap };
+}
+exports.expandMiniscript = expandMiniscript;
+/**
+ * Particularize an expanded ASM expression using the variables in
+ * expansionMap.
+ * This is the kind of the opposite to what expandMiniscript does.
+ * Signatures and preimages are already subsituted by the satisfier calling
+ * this function.
+ */
+function substituteAsm({ expandedAsm, expansionMap }) {
+    //Replace back variables into the pubkeys previously computed.
+    let asm = Object.keys(expansionMap).reduce((accAsm, key) => {
+        const pubkey = expansionMap[key]?.pubkey;
+        if (!pubkey) {
+            throw new Error(`Error: invalid expansionMap for ${key}`);
+        }
+        return accAsm
+            .replaceAll(`<${key}>`, `<${pubkey.toString('hex')}>`)
+            .replaceAll(`<HASH160(${key})>`, `<${bitcoinjs_lib_1.crypto.hash160(pubkey).toString('hex')}>`);
+    }, expandedAsm);
+    //Now clean it and prepare it so that fromASM can be called:
+    asm = asm
+        .trim()
+        //Replace one or more consecutive whitespace characters (spaces, tabs,
+        //or line breaks) with a single space.
+        .replace(/\s+/g, ' ')
+        //Now encode numbers to little endian hex. Note that numbers are not
+        //enclosed in <>, since <> represents hex code already encoded.
+        //The regex below will match one or more digits within a string,
+        //except if the sequence is surrounded by "<" and ">"
+        .replace(/(?<![<])\b\d+\b(?![>])/g, (num) => numberEncodeAsm(Number(num)))
+        //we don't have numbers anymore, now it's safe to remove < and > since we
+        //know that every remaining is either an op_code or a hex encoded number
+        .replace(/[<>]/g, '');
+    return asm;
+}
+function miniscript2Script({ expandedMiniscript, expansionMap }) {
+    const compiled = (0, miniscript_1.compileMiniscript)(expandedMiniscript);
+    if (compiled.issane !== true) {
+        throw new Error(`Error: Miniscript ${expandedMiniscript} is not sane`);
+    }
+    return bitcoinjs_lib_1.script.fromASM(substituteAsm({ expandedAsm: compiled.asm, expansionMap }));
+}
+exports.miniscript2Script = miniscript2Script;
+/**
+ * Assumptions:
+ * The attacker does not have access to any of the private keys of public keys
+ * that participate in the Script.
+ *
+ * The attacker only has access to hash preimages that honest users have access
+ * to as well.
+ *
+ * Pass timeConstraints to search for the first solution with this nLockTime and
+ * nSequence. Throw if no solution is possible using these constraints.
+ *
+ * Don't pass timeConstraints (this is the default) if you want to get the
+ * smallest size solution altogether.
+ *
+ * If a solution is not found this function throws.
+ */
+function satisfyMiniscript({ expandedMiniscript, expansionMap, signatures = [], preimages = [], timeConstraints }) {
+    //convert 'sha256(6c...33)' to: { ['<sha256_preimage(6c...33)>']: '10...5f'}
+    const preimageMap = {};
+    preimages.forEach(preimage => {
+        preimageMap['<' + preimage.digest.replace('(', '_preimage(') + '>'] =
+            '<' + preimage.preimage + '>';
+    });
+    //convert the pubkeys in signatures into [{['<sig(@0)>']: '30450221'}, ...]
+    //get the keyExpressions: @0, @1 from the keys in expansionMap
+    const expandedSignatureMap = {};
+    signatures.forEach(signature => {
+        const pubkeyHex = signature.pubkey.toString('hex');
+        const keyExpression = Object.keys(expansionMap).find(k => expansionMap[k]?.pubkey.toString('hex') === pubkeyHex);
+        expandedSignatureMap['<sig(' + keyExpression + ')>'] =
+            '<' + signature.signature.toString('hex') + '>';
+    });
+    const expandedKnownsMap = { ...preimageMap, ...expandedSignatureMap };
+    const knowns = Object.keys(expandedKnownsMap);
+    //satisfier verifies again internally whether expandedKnownsMap with given knowns is sane
+    const { nonMalleableSats } = (0, miniscript_1.satisfier)(expandedMiniscript, { knowns });
+    if (!Array.isArray(nonMalleableSats) || !nonMalleableSats[0])
+        throw new Error(`Error: unresolvable miniscript ${expandedMiniscript}`);
+    let sat;
+    if (!timeConstraints) {
+        sat = nonMalleableSats[0];
+    }
+    else {
+        sat = nonMalleableSats.find(nonMalleableSat => nonMalleableSat.nSequence === timeConstraints.nSequence &&
+            nonMalleableSat.nLockTime === timeConstraints.nLockTime);
+        if (sat === undefined) {
+            throw new Error(`Error: unresolvable miniscript ${expandedMiniscript}. Could not find solutions for sequence ${timeConstraints.nSequence} & locktime=${timeConstraints.nLockTime}. Signatures are applied to a hash that depends on sequence and locktime. Did you provide all the signatures wrt the signers keys declared and include all preimages?`);
+        }
+    }
+    //substitute signatures and preimages:
+    let expandedAsm = sat.asm;
+    //replace in expandedAsm all the <sig(@0)> and <sha256_preimage(6c...33)>
+    //to <304...01> and <107...5f> ...
+    for (const search in expandedKnownsMap) {
+        const replace = expandedKnownsMap[search];
+        if (!replace || replace === '<>')
+            throw new Error(`Error: invalid expandedKnownsMap`);
+        expandedAsm = expandedAsm.replaceAll(search, replace);
+    }
+    const scriptSatisfaction = bitcoinjs_lib_1.script.fromASM(substituteAsm({ expandedAsm, expansionMap }));
+    return {
+        scriptSatisfaction,
+        nLockTime: sat.nLockTime,
+        nSequence: sat.nSequence
+    };
+}
+exports.satisfyMiniscript = satisfyMiniscript;
+/**
+ *
+ * Use this function instead of bitcoinjs-lib's equivalent `script.number.encode`
+ * when encoding numbers to be compiled with `fromASM` to avoid problems.
+ *
+ * Motivation:
+ *
+ * Numbers in Bitcoin assembly code are represented in hex and in Little Endian.
+ * Decimal: 32766 - Big endian: 0x7FFE - Little Endian: 0xFE7F.
+ *
+ * This function takes an integer and encodes it so that bitcoinjs-lib `fromASM`
+ * can compile it. This is basically what bitcoinjs-lib's `script.number.encode`
+ * does.
+ *
+ * Note that `fromASM` already converts integers from 1 to 16 to
+ * OP_1 ... OP_16 {@link https://github.com/bitcoinjs/bitcoinjs-lib/blob/59b21162a2c4645c64271ca004c7a3755a3d72fb/src/script.js#L33 here}.
+ * This is done in Bitcoin to save some bits.
+ *
+ * Neither this function nor `script.number.encode` convert numbers to
+ * their op code equivalent since this is done later in `fromASM`.
+ *
+ * Both functions simply convert numbers to Little Endian.
+ *
+ * However, the `0` number is an edge case that we specially handle with this
+ * function.
+ *
+ * bitcoinjs-lib's `bscript.number.encode(0)` produces an empty Buffer.
+ * This is what the Bitcoin interpreter does and it is what `script.number.encode` was
+ * implemented to do.
+ *
+ * The problem is `bscript.number.encode(0).toString('hex')` produces an
+ * empty string and thus it should not be used to serialize number zero before `fromASM`.
+ *
+ * A zero should produce the OP_0 ASM symbolic code (corresponding to a `0` when
+ * compiled).
+ *
+ * So, this function will produce a string in hex format in Little Endian
+ * encoding for integers not equal to `0` and it will return `OP_0` for `0`.
+ *
+ * Read more about the this {@link https://github.com/bitcoinjs/bitcoinjs-lib/issues/1799#issuecomment-1122591738 here}.
+ *
+ * Use it in combination with `fromASM` like this:
+ *
+ * ```javascript
+ * //To produce "0 1 OP_ADD":
+ * fromASM(
+ * `${numberEncodeAsm(0)} ${numberEncodeAsm(1)} OP_ADD`
+ *   .trim().replace(/\s+/g, ' ')
+ * )
+ * ```
+ *
+ * @param {number} number An integer.
+ * @returns {string} Returns `"OP_0"` for `number === 0` and a hex string representing other numbers in Little Endian encoding.
+ */
+function numberEncodeAsm(number) {
+    if (Number.isSafeInteger(number) === false) {
+        throw new Error(`Error: invalid number ${number}`);
+    }
+    if (number === 0) {
+        return 'OP_0';
+    }
+    else
+        return bitcoinjs_lib_1.script.number.encode(number).toString('hex');
+}
+exports.numberEncodeAsm = numberEncodeAsm;

package/dist/psbt.d.ts

@@ -0,0 +1,38 @@
+/// <reference types="node" />
+import type { PsbtInput } from 'bip174/src/lib/interfaces';
+import type { KeyInfo } from './types';
+import { Network, Psbt } from 'bitcoinjs-lib';
+/**
+ * This function must do two things:
+ * 1. Check if the `input` can be finalized. If it can not be finalized, throw.
+ *   ie. `Can not finalize input #${inputIndex}`
+ * 2. Create the finalScriptSig and finalScriptWitness Buffers.
+ */
+type FinalScriptsFunc = (inputIndex: number, // Which input is it?
+input: PsbtInput, // The PSBT input contents
+script: Buffer, // The "meaningful" locking script Buffer (redeemScript for P2SH etc.)
+isSegwit: boolean, // Is it segwit?
+isP2SH: boolean, // Is it P2SH?
+isP2WSH: boolean) => {
+    finalScriptSig: Buffer | undefined;
+    finalScriptWitness: Buffer | undefined;
+};
+export declare function finalScriptsFuncFactory(scriptSatisfaction: Buffer, network: Network): FinalScriptsFunc;
+/**
+ * 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 }: {
+    psbt: Psbt;
+    vout: number;
+    txHex?: string;
+    txId?: string;
+    value?: number;
+    sequence: number | undefined;
+    locktime: number | undefined;
+    keysInfo: KeyInfo[];
+    scriptPubKey: Buffer;
+    isSegwit: boolean;
+    witnessScript: Buffer | undefined;
+    redeemScript: Buffer | undefined;
+}): number;
+export {};

package/dist/psbt.js

@@ -0,0 +1,197 @@
+"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"));
+function reverseBuffer(buffer) {
+    if (buffer.length < 1)
+        return buffer;
+    let j = buffer.length - 1;
+    let tmp = 0;
+    for (let i = 0; i < buffer.length / 2; i++) {
+        tmp = buffer[i];
+        buffer[i] = buffer[j];
+        buffer[j] = tmp;
+        j--;
+    }
+    return buffer;
+}
+function witnessStackToScriptWitness(witness) {
+    let buffer = Buffer.allocUnsafe(0);
+    function writeSlice(slice) {
+        buffer = Buffer.concat([buffer, Buffer.from(slice)]);
+    }
+    function writeVarInt(i) {
+        const currentLen = buffer.length;
+        const varintLen = varuint.encodingLength(i);
+        buffer = Buffer.concat([buffer, Buffer.allocUnsafe(varintLen)]);
+        varuint.encode(i, buffer, currentLen);
+    }
+    function writeVarSlice(slice) {
+        writeVarInt(slice.length);
+        writeSlice(slice);
+    }
+    function writeVector(vector) {
+        writeVarInt(vector.length);
+        vector.forEach(writeVarSlice);
+    }
+    writeVector(witness);
+    return buffer;
+}
+function finalScriptsFuncFactory(scriptSatisfaction, network) {
+    const finalScriptsFunc = (_index, _input, lockingScript /*witnessScript or redeemScript*/, isSegwit, isP2SH, _isP2WSH) => {
+        let finalScriptWitness;
+        let finalScriptSig;
+        //p2wsh
+        if (isSegwit && !isP2SH) {
+            const payment = bitcoinjs_lib_1.payments.p2wsh({
+                redeem: { input: scriptSatisfaction, output: lockingScript },
+                network
+            });
+            if (!payment.witness)
+                throw new Error(`Error: p2wsh failed producing a witness`);
+            finalScriptWitness = witnessStackToScriptWitness(payment.witness);
+        }
+        //p2sh-p2wsh
+        else if (isSegwit && isP2SH) {
+            const payment = bitcoinjs_lib_1.payments.p2sh({
+                redeem: bitcoinjs_lib_1.payments.p2wsh({
+                    redeem: { input: scriptSatisfaction, output: lockingScript },
+                    network
+                }),
+                network
+            });
+            if (!payment.witness)
+                throw new Error(`Error: p2sh-p2wsh failed producing a witness`);
+            finalScriptWitness = witnessStackToScriptWitness(payment.witness);
+            finalScriptSig = payment.input;
+        }
+        //p2sh
+        else {
+            finalScriptSig = bitcoinjs_lib_1.payments.p2sh({
+                redeem: { input: scriptSatisfaction, output: lockingScript },
+                network
+            }).input;
+        }
+        return {
+            finalScriptWitness,
+            finalScriptSig
+        };
+    };
+    return finalScriptsFunc;
+}
+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 }) {
+    //Some data-sanity checks:
+    if (!isSegwit && txHex === undefined)
+        throw new Error(`Error: txHex is mandatory for Non-Segwit inputs`);
+    if (isSegwit &&
+        txHex === undefined &&
+        (txId === undefined || value === undefined))
+        throw new Error(`Error: pass txHex or txId+value for Segwit inputs`);
+    if (txHex !== undefined) {
+        const tx = bitcoinjs_lib_1.Transaction.fromHex(txHex);
+        const out = tx?.outs?.[vout];
+        if (!out)
+            throw new Error(`Error: tx ${txHex} does not have vout ${vout}`);
+        const outputScript = out.script;
+        if (!outputScript)
+            throw new Error(`Error: could not extract outputScript for txHex ${txHex} and vout ${vout}`);
+        if (Buffer.compare(outputScript, scriptPubKey) !== 0)
+            throw new Error(`Error: txHex ${txHex} for vout ${vout} does not correspond to scriptPubKey ${scriptPubKey}`);
+        if (txId !== undefined) {
+            if (tx.getId() !== txId)
+                throw new Error(`Error: txId for ${txHex} and vout ${vout} does not correspond to ${txId}`);
+        }
+        else {
+            txId = tx.getId();
+        }
+        if (value !== undefined) {
+            if (out.value !== value)
+                throw new Error(`Error: value for ${txHex} and vout ${vout} does not correspond to ${value}`);
+        }
+        else {
+            value = out.value;
+        }
+    }
+    if (txId === undefined || !value)
+        throw new Error(`Error: txHex+vout required. Alternatively, but ONLY for Segwit inputs, txId+value can also be passed.`);
+    if (locktime !== undefined) {
+        if (psbt.locktime !== 0 && psbt.locktime !== undefined)
+            throw new Error(`Error: transaction locktime has already been set: ${psbt.locktime}`);
+        psbt.setLocktime(locktime);
+    }
+    let inputSequence;
+    if (locktime !== undefined) {
+        if (sequence === undefined) {
+            // for CTV nSequence MUST be <= 0xfffffffe otherwise OP_CHECKLOCKTIMEVERIFY will fail.
+            inputSequence = 0xfffffffe;
+        }
+        else if (sequence > 0xfffffffe) {
+            throw new Error(`Error: incompatible sequence: ${inputSequence} and locktime: ${locktime}`);
+        }
+        else {
+            inputSequence = sequence;
+        }
+    }
+    else {
+        inputSequence = sequence;
+    }
+    const input = {
+        hash: reverseBuffer(Buffer.from(txId, 'hex')),
+        index: vout
+    };
+    if (txHex !== undefined) {
+        input.nonWitnessUtxo = bitcoinjs_lib_1.Transaction.fromHex(txHex).toBuffer();
+    }
+    const bip32Derivation = keysInfo
+        .filter((keyInfo) => keyInfo.pubkey && keyInfo.masterFingerprint && keyInfo.path)
+        .map((keyInfo) => ({
+        masterFingerprint: keyInfo.masterFingerprint,
+        pubkey: keyInfo.pubkey,
+        path: keyInfo.path
+    }));
+    if (bip32Derivation.length)
+        input.bip32Derivation = bip32Derivation;
+    if (isSegwit && txHex !== undefined) {
+        //There's no need to put both witnessUtxo and nonWitnessUtxo
+        input.witnessUtxo = { script: scriptPubKey, value };
+    }
+    if (inputSequence !== undefined)
+        input.sequence = inputSequence;
+    if (witnessScript)
+        input.witnessScript = witnessScript;
+    if (redeemScript)
+        input.redeemScript = redeemScript;
+    psbt.addInput(input);
+    return psbt.data.inputs.length - 1;
+}
+exports.updatePsbt = updatePsbt;

package/dist/re.d.ts

@@ -0,0 +1,21 @@
+export declare const reOriginPath: string;
+export declare const reMasterFingerprint: string;
+export declare const reOrigin: string;
+export declare const reChecksum: string;
+export declare const rePubKey: string;
+export declare const reWIF: string;
+export declare const reXpub: string;
+export declare const reXprv: string;
+export declare const rePath: string;
+export declare const reXpubKey: string;
+export declare const reXprvKey: string;
+export declare const reKeyExp: string;
+export declare const anchorStartAndEnd: (re: string) => string;
+export declare const rePkAnchored: string;
+export declare const reAddrAnchored: string;
+export declare const rePkhAnchored: string;
+export declare const reWpkhAnchored: string;
+export declare const reShWpkhAnchored: string;
+export declare const reShMiniscriptAnchored: string;
+export declare const reShWshMiniscriptAnchored: string;
+export declare const reWshMiniscriptAnchored: string;

package/dist/re.js

@@ -0,0 +1,65 @@
+"use strict";
+// Copyright (c) 2023 Jose-Luis Landabaso - https://bitcoinerlab.com
+// Distributed under the MIT software license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reWshMiniscriptAnchored = exports.reShWshMiniscriptAnchored = exports.reShMiniscriptAnchored = exports.reShWpkhAnchored = exports.reWpkhAnchored = exports.rePkhAnchored = exports.reAddrAnchored = exports.rePkAnchored = exports.anchorStartAndEnd = exports.reKeyExp = exports.reXprvKey = exports.reXpubKey = exports.rePath = exports.reXprv = exports.reXpub = exports.reWIF = exports.rePubKey = exports.reChecksum = exports.reOrigin = exports.reMasterFingerprint = exports.reOriginPath = void 0;
+const checksum_1 = require("./checksum");
+//Regular expressions cheat sheet:
+//https://www.keycdn.com/support/regex-cheat-sheet
+//hardened characters
+const reHardened = String.raw `(['hH])`;
+//a level is a series of integers followed (optional) by a hardener char
+const reLevel = String.raw `(\d+${reHardened}?)`;
+//a path component is a level followed by a slash "/" char
+const rePathComponent = String.raw `(${reLevel}\/)`;
+//A path formed by a series of path components that can be hardened: /2'/23H/23
+exports.reOriginPath = String.raw `(\/${rePathComponent}*${reLevel})`; //The "*" means: "match 0 or more of the previous"
+//an origin is something like this: [d34db33f/44'/0'/0'] where the path is optional. The fingerPrint is 8 chars hex
+exports.reMasterFingerprint = String.raw `[0-9a-fA-F]{8}`;
+exports.reOrigin = String.raw `(\[${exports.reMasterFingerprint}(${exports.reOriginPath})?\])`;
+exports.reChecksum = String.raw `(#[${checksum_1.CHECKSUM_CHARSET}]{8})`;
+//Something like this: 0252972572d465d016d4c501887b8df303eee3ed602c056b1eb09260dfa0da0ab2
+//as explained here: github.com/bitcoin/bitcoin/blob/master/doc/descriptors.md#reference
+const reCompressedPubKey = String.raw `((02|03)[0-9a-fA-F]{64})`;
+const reUncompressedPubKey = String.raw `(04[0-9a-fA-F]{128})`;
+exports.rePubKey = String.raw `(${reCompressedPubKey}|${reUncompressedPubKey})`;
+//https://learnmeabitcoin.com/technical/wif
+//5, K, L for mainnet, 5: uncompressed, {K, L}: compressed
+//c, 9, testnet, c: compressed, 9: uncompressed
+exports.reWIF = String.raw `([5KLc9][1-9A-HJ-NP-Za-km-z]{50,51})`;
+//x for mainnet, t for testnet
+exports.reXpub = String.raw `([xXtT]pub[1-9A-HJ-NP-Za-km-z]{79,108})`;
+exports.reXprv = String.raw `([xXtT]prv[1-9A-HJ-NP-Za-km-z]{79,108})`;
+//reRangeLevel is like reLevel but using a wildcard "*"
+const reRangeLevel = String.raw `(\*(${reHardened})?)`;
+//A path can be finished with stuff like this: /23 or /23h or /* or /*'
+exports.rePath = String.raw `(\/(${rePathComponent})*(${reRangeLevel}|${reLevel}))`;
+//rePath is optional (note the "zero"): Followed by zero or more /NUM or /NUM' path elements to indicate unhardened or hardened derivation steps between the fingerprint and the key or xpub/xprv root that follows
+exports.reXpubKey = String.raw `(${exports.reXpub})(${exports.rePath})?`;
+exports.reXprvKey = String.raw `(${exports.reXprv})(${exports.rePath})?`;
+//actualKey is the keyExpression without optional origin
+const reActualKey = String.raw `(${exports.reXpubKey}|${exports.reXprvKey}|${exports.rePubKey}|${exports.reWIF})`;
+//reOrigin is optional: Optionally, key origin information, consisting of:
+//Matches a key expression: wif, xpub, xprv or pubkey:
+exports.reKeyExp = String.raw `(${exports.reOrigin})?(${reActualKey})`;
+const rePk = String.raw `pk\((.*?)\)`; //Matches anything. We assert later in the code that the pubkey is valid.
+const reAddr = String.raw `addr\((.*?)\)`; //Matches anything. We assert later in the code that the address is valid.
+const rePkh = String.raw `pkh\(${exports.reKeyExp}\)`;
+const reWpkh = String.raw `wpkh\(${exports.reKeyExp}\)`;
+const reShWpkh = String.raw `sh\(wpkh\(${exports.reKeyExp}\)\)`;
+const reMiniscript = String.raw `(.*?)`; //Matches anything. We assert later in the code that miniscripts are valid and sane.
+//RegExp makers:
+const makeReSh = (re) => String.raw `sh\(${re}\)`;
+const makeReWsh = (re) => String.raw `wsh\(${re}\)`;
+const makeReShWsh = (re) => makeReSh(makeReWsh(re));
+const anchorStartAndEnd = (re) => String.raw `^${re}$`; //starts and finishes like re (not composable)
+exports.anchorStartAndEnd = anchorStartAndEnd;
+const composeChecksum = (re) => String.raw `${re}(${exports.reChecksum})?`; //it's optional (note the "?")
+exports.rePkAnchored = (0, exports.anchorStartAndEnd)(composeChecksum(rePk));
+exports.reAddrAnchored = (0, exports.anchorStartAndEnd)(composeChecksum(reAddr));
+exports.rePkhAnchored = (0, exports.anchorStartAndEnd)(composeChecksum(rePkh));
+exports.reWpkhAnchored = (0, exports.anchorStartAndEnd)(composeChecksum(reWpkh));
+exports.reShWpkhAnchored = (0, exports.anchorStartAndEnd)(composeChecksum(reShWpkh));
+exports.reShMiniscriptAnchored = (0, exports.anchorStartAndEnd)(composeChecksum(makeReSh(reMiniscript)));
+exports.reShWshMiniscriptAnchored = (0, exports.anchorStartAndEnd)(composeChecksum(makeReShWsh(reMiniscript)));
+exports.reWshMiniscriptAnchored = (0, exports.anchorStartAndEnd)(composeChecksum(makeReWsh(reMiniscript)));