@kukks/bitcoin-descriptors 3.0.2

package/dist/psbt.js

@@ -0,0 +1,200 @@
+// Copyright (c) 2025 Jose-Luis Landabaso - https://bitcoinerlab.com
+// Distributed under the MIT software license
+import * as btc from '@scure/btc-signer';
+import { bip32Path } from '@scure/btc-signer';
+import { RawTx, RawOldTx } from '@scure/btc-signer/script.js';
+import { sha256 } from '@noble/hashes/sha2.js';
+import { hex } from '@scure/base';
+import { equalBytes } from '@scure/btc-signer/utils.js';
+import { decompileScript, readUInt32BE } from './scriptUtils.js';
+/**
+ * Computes final scripts for miniscript-based inputs.
+ *
+ * @param scriptSatisfaction - The script satisfaction (input script data)
+ * @param lockingScript - The "meaningful" locking script (witnessScript or redeemScript)
+ * @param isSegwit - Whether this is a segwit input
+ * @param isP2SH - Whether this is a P2SH input
+ * @param network - The network
+ * @returns Object with finalScriptSig and finalScriptWitness (as Uint8Array[])
+ */
+export function computeFinalScripts(scriptSatisfaction, lockingScript, isSegwit, isP2SH, redeemScript) {
+    let finalScriptWitness;
+    let finalScriptSig;
+    // Helper: decompile scriptSatisfaction into witness items
+    function satisfactionToWitness() {
+        const chunks = decompileScript(scriptSatisfaction);
+        if (!chunks)
+            throw new Error('Could not decompile script satisfaction');
+        return chunks.map(chunk => typeof chunk === 'number'
+            ? new Uint8Array(0) // OP_0 or opcodes become empty push
+            : chunk);
+    }
+    //p2wsh: witness = [satisfaction chunks..., witnessScript]
+    if (isSegwit && !isP2SH) {
+        const witness = satisfactionToWitness();
+        witness.push(lockingScript);
+        finalScriptWitness = witness;
+    }
+    //p2sh-p2wsh: witness = [satisfaction chunks..., witnessScript], scriptSig = push of redeemScript
+    else if (isSegwit && isP2SH) {
+        const witness = satisfactionToWitness();
+        witness.push(lockingScript);
+        finalScriptWitness = witness;
+        // finalScriptSig is a serialized script that pushes the redeemScript
+        const rs = redeemScript ?? lockingScript;
+        finalScriptSig = btc.Script.encode([rs]);
+    }
+    //p2sh: scriptSig = satisfaction + push of redeemScript
+    else {
+        // Build scriptSig: scriptSatisfaction bytes + push of lockingScript (redeemScript)
+        const chunks = decompileScript(scriptSatisfaction);
+        if (!chunks)
+            throw new Error('Could not decompile script satisfaction');
+        const scriptItems = chunks.map(chunk => typeof chunk === 'number' ? chunk : chunk);
+        scriptItems.push(lockingScript);
+        finalScriptSig = btc.Script.encode(scriptItems);
+    }
+    return { finalScriptSig, finalScriptWitness };
+}
+/**
+ * Important: Read comments on descriptor.updatePsbt regarding not passing txHex
+ */
+export function updatePsbt({ psbt, vout, txHex, txId, value, sequence, locktime, keysInfo, scriptPubKey, isSegwit, tapInternalKey, 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 &&
+        txHex === undefined &&
+        (txId === undefined || value === undefined))
+        throw new Error(`Error: pass txHex or txId+value for Segwit inputs`);
+    if (txHex !== undefined) {
+        const rawTxBytes = hex.decode(txHex);
+        // Use RawTx.decode instead of Transaction.fromRaw to avoid script
+        // validation that rejects bare P2PK and other non-wrapped output types.
+        const parsed = RawTx.decode(rawTxBytes);
+        const out = parsed.outputs[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 (!equalBytes(outputScript, scriptPubKey))
+            throw new Error(`Error: txHex ${txHex} for vout ${vout} does not correspond to scriptPubKey ${hex.encode(scriptPubKey)}`);
+        // Compute txid: double-SHA256 of non-witness serialization, reversed
+        const nonWitnessSerialization = RawOldTx.encode(parsed);
+        const txidHash = sha256(sha256(nonWitnessSerialization));
+        const computedTxId = hex.encode(txidHash.slice().reverse());
+        if (txId !== undefined) {
+            if (computedTxId !== txId)
+                throw new Error(`Error: txId for ${txHex} and vout ${vout} does not correspond to ${txId}`);
+        }
+        else {
+            txId = computedTxId;
+        }
+        if (value !== undefined) {
+            if (BigInt(out.amount) !== BigInt(value))
+                throw new Error(`Error: value for ${txHex} and vout ${vout} does not correspond to ${value}`);
+        }
+        else {
+            value = BigInt(out.amount);
+        }
+    }
+    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) {
+        const currentLocktime = psbt.lockTime;
+        if (currentLocktime &&
+            currentLocktime !== locktime &&
+            currentLocktime !== 0)
+            throw new Error(`Error: transaction locktime was already set with a different value: ${locktime} != ${currentLocktime}`);
+        // nLockTime only works if at least one of the transaction inputs has an
+        // nSequence value that is below 0xffffffff. Let's make sure that at least
+        // this input's sequence < 0xffffffff
+        if (sequence === undefined) {
+            sequence = rbf ? 0xfffffffd : 0xfffffffe;
+        }
+        else if (sequence > 0xfffffffe) {
+            throw new Error(`Error: incompatible sequence: ${sequence} and locktime: ${locktime}`);
+        }
+        if (sequence === undefined && rbf)
+            sequence = 0xfffffffd;
+        // Set locktime via scure's internal global field
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        psbt.global.fallbackLocktime = locktime;
+    }
+    else {
+        if (sequence === undefined) {
+            if (rbf)
+                sequence = 0xfffffffd;
+            else
+                sequence = 0xffffffff;
+        }
+    }
+    // Build input in @scure/btc-signer format
+    const input = {
+        txid: hex.decode(txId),
+        index: vout
+    };
+    if (txHex !== undefined) {
+        input['nonWitnessUtxo'] = hex.decode(txHex);
+    }
+    if (tapInternalKey) {
+        //Taproot
+        const tapBip32Derivation = keysInfo
+            .filter((keyInfo) => keyInfo.pubkey && keyInfo.masterFingerprint && keyInfo.path)
+            .map((keyInfo) => {
+            const pubkey = keyInfo.pubkey;
+            if (!pubkey)
+                throw new Error(`key ${keyInfo.keyExpression} missing pubkey`);
+            return [
+                pubkey,
+                {
+                    hashes: [], // Empty for tr(KEY) taproot key spend
+                    der: {
+                        fingerprint: readUInt32BE(keyInfo.masterFingerprint),
+                        path: bip32Path(keyInfo.path)
+                    }
+                }
+            ];
+        });
+        if (tapBip32Derivation.length)
+            input['tapBip32Derivation'] = tapBip32Derivation;
+        input['tapInternalKey'] = tapInternalKey;
+        //TODO: currently only single-key taproot supported.
+        if (tapBip32Derivation.length > 1)
+            throw new Error('Only single key taproot inputs are currently supported');
+    }
+    else {
+        const bip32Derivation = keysInfo
+            .filter((keyInfo) => keyInfo.pubkey && keyInfo.masterFingerprint && keyInfo.path)
+            .map((keyInfo) => {
+            const pubkey = keyInfo.pubkey;
+            if (!pubkey)
+                throw new Error(`key ${keyInfo.keyExpression} missing pubkey`);
+            return [
+                pubkey,
+                {
+                    fingerprint: readUInt32BE(keyInfo.masterFingerprint),
+                    path: bip32Path(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, amount: BigInt(value) };
+    }
+    if (sequence !== undefined)
+        input['sequence'] = sequence;
+    if (witnessScript)
+        input['witnessScript'] = witnessScript;
+    if (redeemScript)
+        input['redeemScript'] = redeemScript;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    psbt.addInput(input);
+    return psbt.inputsLength - 1;
+}

package/dist/re.d.ts

@@ -0,0 +1,31 @@
+export declare const reOriginPath: string;
+export declare const reMasterFingerprint: string;
+export declare const reOrigin: string;
+export declare const reChecksum: string;
+export declare const reNonSegwitPubKey: string;
+export declare const reSegwitPubKey: string;
+export declare const reTaprootPubKey: 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 reNonSegwitKeyExp: string;
+export declare const reSegwitKeyExp: string;
+export declare const reTaprootKeyExp: string;
+export declare const reNonSegwitSortedMulti: string;
+export declare const reSegwitSortedMulti: 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 reTrSingleKeyAnchored: string;
+export declare const reShSortedMultiAnchored: string;
+export declare const reWshSortedMultiAnchored: string;
+export declare const reShWshSortedMultiAnchored: string;
+export declare const reShMiniscriptAnchored: string;
+export declare const reShWshMiniscriptAnchored: string;
+export declare const reWshMiniscriptAnchored: string;

package/dist/re.js

@@ -0,0 +1,75 @@
+// Copyright (c) 2025 Jose-Luis Landabaso - https://bitcoinerlab.com
+// Distributed under the MIT software license
+import { CHECKSUM_CHARSET } from './checksum.js';
+//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
+export const 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
+export const reMasterFingerprint = String.raw `[0-9a-fA-F]{8}`;
+export const reOrigin = String.raw `(\[${reMasterFingerprint}(${reOriginPath})?\])`;
+export const reChecksum = String.raw `(#[${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})`;
+const reXOnlyPubKey = String.raw `([0-9a-fA-F]{64})`;
+export const reNonSegwitPubKey = String.raw `(${reCompressedPubKey}|${reUncompressedPubKey})`;
+export const reSegwitPubKey = String.raw `(${reCompressedPubKey})`;
+export const reTaprootPubKey = String.raw `(${reCompressedPubKey}|${reXOnlyPubKey})`;
+//https://learnmeabitcoin.com/technical/wif
+//5, K, L for mainnet, 5: uncompressed, {K, L}: compressed
+//c, 9, testnet, c: compressed, 9: uncompressed
+export const reWIF = String.raw `([5KLc9][1-9A-HJ-NP-Za-km-z]{50,51})`;
+//x for mainnet, t for testnet
+export const reXpub = String.raw `([xXtT]pub[1-9A-HJ-NP-Za-km-z]{79,108})`;
+export const 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 /*'
+export const 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
+export const reXpubKey = String.raw `(${reXpub})(${rePath})?`;
+export const reXprvKey = String.raw `(${reXprv})(${rePath})?`;
+//actualKey is the keyExpression without optional origin
+const reNonSegwitActualKey = String.raw `(${reXpubKey}|${reXprvKey}|${reNonSegwitPubKey}|${reWIF})`;
+const reSegwitActualKey = String.raw `(${reXpubKey}|${reXprvKey}|${reSegwitPubKey}|${reWIF})`;
+const reTaprootActualKey = String.raw `(${reXpubKey}|${reXprvKey}|${reTaprootPubKey}|${reWIF})`;
+//reOrigin is optional: Optionally, key origin information, consisting of:
+//Matches a key expression: wif, xpub, xprv or pubkey:
+export const reNonSegwitKeyExp = String.raw `(${reOrigin})?(${reNonSegwitActualKey})`;
+export const reSegwitKeyExp = String.raw `(${reOrigin})?(${reSegwitActualKey})`;
+export const reTaprootKeyExp = String.raw `(${reOrigin})?(${reTaprootActualKey})`;
+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\(${reNonSegwitKeyExp}\)`;
+const reWpkh = String.raw `wpkh\(${reSegwitKeyExp}\)`;
+const reShWpkh = String.raw `sh\(wpkh\(${reSegwitKeyExp}\)\)`;
+const reTrSingleKey = String.raw `tr\(${reTaprootKeyExp}\)`; // TODO: tr(KEY,TREE) not yet supported. TrSingleKey used for tr(KEY)
+export const reNonSegwitSortedMulti = String.raw `sortedmulti\(((?:1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20)(?:,${reNonSegwitKeyExp})+)\)`;
+export const reSegwitSortedMulti = String.raw `sortedmulti\(((?:1|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20)(?:,${reSegwitKeyExp})+)\)`;
+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));
+export const anchorStartAndEnd = (re) => String.raw `^${re}$`; //starts and finishes like re (not composable)
+const composeChecksum = (re) => String.raw `${re}(${reChecksum})?`; //it's optional (note the "?")
+export const rePkAnchored = anchorStartAndEnd(composeChecksum(rePk));
+export const reAddrAnchored = anchorStartAndEnd(composeChecksum(reAddr));
+export const rePkhAnchored = anchorStartAndEnd(composeChecksum(rePkh));
+export const reWpkhAnchored = anchorStartAndEnd(composeChecksum(reWpkh));
+export const reShWpkhAnchored = anchorStartAndEnd(composeChecksum(reShWpkh));
+export const reTrSingleKeyAnchored = anchorStartAndEnd(composeChecksum(reTrSingleKey));
+export const reShSortedMultiAnchored = anchorStartAndEnd(composeChecksum(makeReSh(reNonSegwitSortedMulti)));
+export const reWshSortedMultiAnchored = anchorStartAndEnd(composeChecksum(makeReWsh(reSegwitSortedMulti)));
+export const reShWshSortedMultiAnchored = anchorStartAndEnd(composeChecksum(makeReShWsh(reSegwitSortedMulti)));
+export const reShMiniscriptAnchored = anchorStartAndEnd(composeChecksum(makeReSh(reMiniscript)));
+export const reShWshMiniscriptAnchored = anchorStartAndEnd(composeChecksum(makeReShWsh(reMiniscript)));
+export const reWshMiniscriptAnchored = anchorStartAndEnd(composeChecksum(makeReWsh(reMiniscript)));

package/dist/scriptExpressions.d.ts

@@ -0,0 +1,62 @@
+import { Network } from './networks.js';
+import type { BIP32Interface } from './types.js';
+/** @function */
+export declare const pkhBIP32: ({ masterNode, network, keyPath, account, change, index, isPublic }: {
+    masterNode: BIP32Interface;
+    /** @default networks.bitcoin */
+    network?: Network;
+    account: number;
+    change?: number | undefined;
+    index?: number | undefined | "*";
+    keyPath?: string;
+    /**
+     * Compute an xpub or xprv
+     * @default true
+     */
+    isPublic?: boolean;
+}) => string;
+/** @function */
+export declare const shWpkhBIP32: ({ masterNode, network, keyPath, account, change, index, isPublic }: {
+    masterNode: BIP32Interface;
+    /** @default networks.bitcoin */
+    network?: Network;
+    account: number;
+    change?: number | undefined;
+    index?: number | undefined | "*";
+    keyPath?: string;
+    /**
+     * Compute an xpub or xprv
+     * @default true
+     */
+    isPublic?: boolean;
+}) => string;
+/** @function */
+export declare const wpkhBIP32: ({ masterNode, network, keyPath, account, change, index, isPublic }: {
+    masterNode: BIP32Interface;
+    /** @default networks.bitcoin */
+    network?: Network;
+    account: number;
+    change?: number | undefined;
+    index?: number | undefined | "*";
+    keyPath?: string;
+    /**
+     * Compute an xpub or xprv
+     * @default true
+     */
+    isPublic?: boolean;
+}) => string;
+/** @function */
+export declare const trBIP32: ({ masterNode, network, keyPath, account, change, index, isPublic }: {
+    masterNode: BIP32Interface;
+    /** @default networks.bitcoin */
+    network?: Network;
+    account: number;
+    change?: number | undefined;
+    index?: number | undefined | "*";
+    keyPath?: string;
+    /**
+     * Compute an xpub or xprv
+     * @default true
+     */
+    isPublic?: boolean;
+}) => string;

package/dist/scriptExpressions.js

@@ -0,0 +1,47 @@
+import { networks } from './networks.js';
+import { keyExpressionBIP32 } from './keyExpressions.js';
+function assertStandardKeyPath(keyPath) {
+    // Regular expression to match "/change/index" or "/change/*" format
+    const regex = /^\/[01]\/(\d+|\*)$/;
+    if (!regex.test(keyPath)) {
+        throw new Error("Error: Key path must be in the format '/change/index', where change is either 0 or 1 and index is a non-negative integer.");
+    }
+}
+function standardExpressionsBIP32Maker(purpose, scriptTemplate) {
+    /**
+     * Computes the standard descriptor based on given parameters.
+     *
+     * You can define the output location either by:
+     * - Providing the full `keyPath` (e.g., "/0/2").
+     * OR
+     * - Specifying the `change` and `index` values separately (e.g., `{change:0, index:2}`).
+     *
+     * For ranged indexing, the `index` can be set as a wildcard '*'. For example:
+     * - `keyPath="/0/*"`
+     * OR
+     * - `{change:0, index:'*'}`.
+     */
+    function standardScriptExpressionBIP32({ masterNode, network = networks.bitcoin, keyPath, account, change, index, isPublic = true }) {
+        const originPath = `/${purpose}'/${network.bech32 === networks.bitcoin.bech32 ? 0 : 1}'/${account}'`;
+        if (keyPath !== undefined)
+            assertStandardKeyPath(keyPath);
+        const keyExpression = keyExpressionBIP32({
+            masterNode,
+            originPath,
+            keyPath,
+            change,
+            index,
+            isPublic
+        });
+        return scriptTemplate.replace('KEYEXPRESSION', keyExpression);
+    }
+    return standardScriptExpressionBIP32;
+}
+/** @function */
+export const pkhBIP32 = standardExpressionsBIP32Maker(44, 'pkh(KEYEXPRESSION)');
+/** @function */
+export const shWpkhBIP32 = standardExpressionsBIP32Maker(49, 'sh(wpkh(KEYEXPRESSION))');
+/** @function */
+export const wpkhBIP32 = standardExpressionsBIP32Maker(84, 'wpkh(KEYEXPRESSION)');
+/** @function */
+export const trBIP32 = standardExpressionsBIP32Maker(86, 'tr(KEYEXPRESSION)');

package/dist/scriptUtils.d.ts

@@ -0,0 +1,19 @@
+export declare function varintEncodingLength(n: number): number;
+/**
+ * Convert ASM string to script bytes.
+ * Applies minimal encoding rules matching bitcoinjs-lib: single-byte data
+ * pushes 0x01-0x10 are converted to OP_1-OP_16, and empty data is OP_0.
+ */
+export declare function fromASM(asm: string): Uint8Array;
+/**
+ * Decompile script to array of opcodes and data.
+ * Returns opcode numbers and Uint8Array data pushes.
+ */
+export declare function decompileScript(script: Uint8Array): (number | Uint8Array)[] | null;
+/**
+ * Encode a number for use in ASM.
+ * Returns a hex string for non-zero numbers, "OP_0" for zero.
+ */
+export declare function numberEncodeAsm(number: number): string;
+/** Read a 4-byte big-endian unsigned integer from a Uint8Array. */
+export declare function readUInt32BE(buf: Uint8Array): number;

package/dist/scriptUtils.js

@@ -0,0 +1,124 @@
+// Copyright (c) 2025 Jose-Luis Landabaso - https://bitcoinerlab.com
+// Distributed under the MIT software license
+import * as btc from '@scure/btc-signer';
+const { Script, OP, ScriptNum } = btc;
+import { hex } from '@scure/base';
+// ---- Varint encoding ----
+export function varintEncodingLength(n) {
+    if (n < 0xfd)
+        return 1;
+    if (n <= 0xffff)
+        return 3;
+    if (n <= 0xffffffff)
+        return 5;
+    return 9;
+}
+// ---- Script helpers ----
+// Build set of valid btc-signer opcode names
+const SIGNER_OP_NAMES = new Set();
+for (const key of Object.keys(OP)) {
+    if (isNaN(Number(key))) {
+        SIGNER_OP_NAMES.add(key);
+    }
+}
+function asmTokenToSignerOp(token) {
+    if (token === 'OP_0' || token === 'OP_FALSE')
+        return 'OP_0';
+    if (token === 'OP_1' || token === 'OP_TRUE')
+        return 'OP_1';
+    for (let i = 2; i <= 16; i++) {
+        if (token === `OP_${i}`)
+            return `OP_${i}`;
+    }
+    if (token === '1NEGATE' || token === 'OP_1NEGATE')
+        return '1NEGATE';
+    if (token.startsWith('OP_')) {
+        const stripped = token.slice(3);
+        if (SIGNER_OP_NAMES.has(stripped))
+            return stripped;
+    }
+    if (SIGNER_OP_NAMES.has(token))
+        return token;
+    return undefined;
+}
+/**
+ * Convert ASM string to script bytes.
+ * Applies minimal encoding rules matching bitcoinjs-lib: single-byte data
+ * pushes 0x01-0x10 are converted to OP_1-OP_16, and empty data is OP_0.
+ */
+export function fromASM(asm) {
+    const tokens = asm.trim().split(/\s+/);
+    const scriptElements = [];
+    for (const token of tokens) {
+        if (token === '')
+            continue;
+        const op = asmTokenToSignerOp(token);
+        if (op !== undefined) {
+            scriptElements.push(op);
+        }
+        else {
+            try {
+                const data = hex.decode(token);
+                if (data.length === 0) {
+                    scriptElements.push('OP_0');
+                }
+                else if (data.length === 1 && data[0] >= 1 && data[0] <= 16) {
+                    scriptElements.push(`OP_${data[0]}`);
+                }
+                else if (data.length === 1 && data[0] === 0x81) {
+                    scriptElements.push('1NEGATE');
+                }
+                else {
+                    scriptElements.push(data);
+                }
+            }
+            catch {
+                throw new Error(`Error: unknown ASM token: ${token}`);
+            }
+        }
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return Script.encode(scriptElements);
+}
+/**
+ * Decompile script to array of opcodes and data.
+ * Returns opcode numbers and Uint8Array data pushes.
+ */
+export function decompileScript(script) {
+    try {
+        const decoded = Script.decode(script);
+        return decoded.map(item => {
+            if (typeof item === 'number')
+                return item;
+            if (item instanceof Uint8Array)
+                return item;
+            // String opcode: convert to number
+            const opNum = OP[item];
+            if (opNum !== undefined)
+                return opNum;
+            return item;
+        });
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Encode a number for use in ASM.
+ * Returns a hex string for non-zero numbers, "OP_0" for zero.
+ */
+export function numberEncodeAsm(number) {
+    if (Number.isSafeInteger(number) === false) {
+        throw new Error(`Error: invalid number ${number}`);
+    }
+    if (number === 0) {
+        return 'OP_0';
+    }
+    const encoded = ScriptNum(6).encode(BigInt(number));
+    return hex.encode(encoded);
+}
+// ---- Byte helpers ----
+/** Read a 4-byte big-endian unsigned integer from a Uint8Array. */
+export function readUInt32BE(buf) {
+    return ((buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3]) >>> 0;
+}

package/dist/signers.d.ts

@@ -0,0 +1,62 @@
+import type { PsbtLike } from './psbt.js';
+import type { ECPairInterface, BIP32Interface } from './types.js';
+/**
+ * Signs a specific input of a PSBT with an ECPair.
+ *
+ * Uses @scure/btc-signer's signIdx which automatically handles
+ * Taproot key tweaking internally.
+ *
+ * @param {Object} params - The parameters object
+ * @param {PsbtLike} params.psbt - The PSBT to sign
+ * @param {number} params.index - The input index to sign
+ * @param {ECPairInterface} params.ecpair - The ECPair to sign with
+ */
+export declare function signInputECPair({ psbt, index, ecpair }: {
+    psbt: PsbtLike;
+    index: number;
+    ecpair: ECPairInterface;
+}): void;
+/**
+ * Signs all inputs of a PSBT with an ECPair.
+ *
+ * Uses @scure/btc-signer's sign which automatically handles
+ * Taproot key tweaking internally.
+ *
+ * @param {Object} params - The parameters object
+ * @param {PsbtLike} params.psbt - The PSBT to sign
+ * @param {ECPairInterface} params.ecpair - The ECPair to sign with
+ */
+export declare function signECPair({ psbt, ecpair }: {
+    psbt: PsbtLike;
+    ecpair: ECPairInterface;
+}): void;
+/**
+ * Signs a specific input of a PSBT with a BIP32 node.
+ *
+ * Handles Taproot inputs via tapBip32Derivation, and non-Taproot via
+ * @scure/btc-signer's signIdx with an HDKey adapter.
+ *
+ * @param {Object} params - The parameters object
+ * @param {PsbtLike} params.psbt - The PSBT to sign
+ * @param {number} params.index - The input index to sign
+ * @param {BIP32Interface} params.node - The BIP32 node to sign with
+ */
+export declare function signInputBIP32({ psbt, index, node }: {
+    psbt: PsbtLike;
+    index: number;
+    node: BIP32Interface;
+}): void;
+/**
+ * Signs all inputs of a PSBT with a BIP32 master node.
+ *
+ * First signs any Taproot inputs via tapBip32Derivation, then uses
+ * @scure/btc-signer's sign for remaining non-Taproot inputs.
+ *
+ * @param {Object} params - The parameters object
+ * @param {PsbtLike} params.psbt - The PSBT to sign
+ * @param {BIP32Interface} params.masterNode - The BIP32 master node to sign with
+ */
+export declare function signBIP32({ psbt, masterNode }: {
+    psbt: PsbtLike;
+    masterNode: BIP32Interface;
+}): void;