@bitcoinerlab/descriptors-core 3.1.0

package/dist/adapters/scureKeys.js

@@ -0,0 +1,135 @@
+"use strict";
+// Copyright (c) 2026 Jose-Luis Landabaso - https://bitcoinerlab.com
+// Distributed under the MIT software license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapScurePrivateKey = wrapScurePrivateKey;
+exports.wrapScurePublicKey = wrapScurePublicKey;
+exports.wrapScureHDKey = wrapScureHDKey;
+const bip32_1 = require("@scure/bip32");
+const base_1 = require("@scure/base");
+const secp256k1_js_1 = require("@noble/curves/secp256k1.js");
+const utils_js_1 = require("@noble/curves/utils.js");
+const common_1 = require("./scure/common");
+const CURVE_N = BigInt('0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141');
+function mod(a, n) {
+    const result = a % n;
+    return result >= 0n ? result : result + n;
+}
+function tweakPrivateKey(privateKey, tweak, publicKey) {
+    if (tweak.length !== 32)
+        throw new Error('Error: invalid tweak value');
+    const tweakNum = (0, utils_js_1.bytesToNumberBE)(tweak);
+    if (tweakNum <= 0n || tweakNum >= CURVE_N)
+        throw new Error('Error: invalid tweak value');
+    let d = (0, utils_js_1.bytesToNumberBE)(privateKey);
+    if (publicKey[0] === 0x03)
+        d = mod(-d, CURVE_N);
+    const tweaked = mod(d + tweakNum, CURVE_N);
+    if (tweaked === 0n)
+        throw new Error('Error: invalid tweak value');
+    return (0, utils_js_1.numberToBytesBE)(tweaked, 32);
+}
+function wrapScurePrivateKey(privateKey, compressed = true) {
+    if (!secp256k1_js_1.secp256k1.utils.isValidSecretKey(privateKey))
+        throw new Error('Error: invalid private key');
+    const compressedPublicKey = secp256k1_js_1.secp256k1.getPublicKey(privateKey, true);
+    const publicKey = compressed
+        ? compressedPublicKey
+        : secp256k1_js_1.secp256k1.getPublicKey(privateKey, false);
+    const xOnlyPubkey = compressedPublicKey.slice(1, 33);
+    return {
+        publicKey,
+        privateKey,
+        sign(hash) {
+            return secp256k1_js_1.secp256k1.sign(hash, privateKey, {
+                prehash: false,
+                lowS: true,
+                format: 'compact'
+            });
+        },
+        verify(hash, signature) {
+            return secp256k1_js_1.secp256k1.verify(signature, hash, publicKey, {
+                prehash: false,
+                lowS: true,
+                format: 'compact'
+            });
+        },
+        tweak(t) {
+            return wrapScurePrivateKey(tweakPrivateKey(privateKey, t, compressedPublicKey), compressed);
+        },
+        signSchnorr(hash) {
+            return secp256k1_js_1.schnorr.sign(hash, privateKey);
+        },
+        verifySchnorr(hash, signature) {
+            return secp256k1_js_1.schnorr.verify(signature, hash, xOnlyPubkey);
+        }
+    };
+}
+function wrapScurePublicKey(publicKey) {
+    if (!secp256k1_js_1.secp256k1.utils.isValidPublicKey(publicKey))
+        throw new Error('Error: invalid public key point');
+    const compressedPubkey = publicKey.length === 33
+        ? publicKey
+        : secp256k1_js_1.secp256k1.Point.fromHex(base_1.hex.encode(publicKey)).toBytes(true);
+    const xOnlyPubkey = compressedPubkey.slice(1, 33);
+    return {
+        publicKey,
+        sign() {
+            throw new Error('Error: private key is required for signing');
+        },
+        verify(hash, signature) {
+            return secp256k1_js_1.secp256k1.verify(signature, hash, publicKey, {
+                prehash: false,
+                lowS: true,
+                format: 'compact'
+            });
+        },
+        tweak() {
+            throw new Error('Error: private key is required for tweak');
+        },
+        verifySchnorr(hash, signature) {
+            return secp256k1_js_1.schnorr.verify(signature, hash, xOnlyPubkey);
+        }
+    };
+}
+function normalizePath(path) {
+    const p = path.replaceAll('H', "'").replaceAll('h', "'");
+    if (p === 'm' || p === "m'")
+        return 'm';
+    if (p.startsWith('m/'))
+        return p;
+    if (p.startsWith('/'))
+        return `m${p}`;
+    return `m/${p}`;
+}
+function wrapScureHDKey(node) {
+    if (!node.publicKey)
+        throw new Error('Error: scure HDKey is missing publicKey for BIP32 usage');
+    return {
+        publicKey: node.publicKey,
+        ...(node.privateKey ? { privateKey: node.privateKey } : {}),
+        fingerprint: (0, common_1.uint32ToBytesBE)(node.fingerprint),
+        derive(index) {
+            return wrapScureHDKey(node.deriveChild(index));
+        },
+        derivePath(path) {
+            return wrapScureHDKey(node.derive(normalizePath(path)));
+        },
+        neutered() {
+            return wrapScureHDKey(bip32_1.HDKey.fromExtendedKey(node.publicExtendedKey, node.versions));
+        },
+        toBase58() {
+            return node.privateKey ? node.privateExtendedKey : node.publicExtendedKey;
+        },
+        sign(hash) {
+            if (!node.privateKey)
+                throw new Error('Error: cannot sign with neutered ScureHDKeyLike');
+            return node.sign(hash);
+        },
+        tweak(t) {
+            if (!node.privateKey)
+                throw new Error('Error: cannot tweak a neutered ScureHDKeyLike');
+            return wrapScurePrivateKey(node.privateKey).tweak(t);
+        }
+    };
+}

package/dist/bip174.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Minimal local subset of the bip174 type surface used by this codebase.
+ *
+ * This file is intentionally self-contained so the library can stop exposing
+ * `bip174` as a dependency.
+ */
+/** @internal */
+export interface KeyValue {
+    key: Uint8Array;
+    value: Uint8Array;
+}
+/** @internal */
+export interface PartialSig {
+    pubkey: Uint8Array;
+    signature: Uint8Array;
+}
+/** @internal */
+export interface Bip32Derivation {
+    masterFingerprint: Uint8Array;
+    pubkey: Uint8Array;
+    path: string;
+}
+/** @internal */
+export interface WitnessUtxo {
+    script: Uint8Array;
+    value: bigint;
+}
+/** @internal */
+export type NonWitnessUtxo = Uint8Array;
+/** @internal */
+export type SighashType = number;
+/** @internal */
+export type RedeemScript = Uint8Array;
+/** @internal */
+export type WitnessScript = Uint8Array;
+/** @internal */
+export type FinalScriptSig = Uint8Array;
+/** @internal */
+export type FinalScriptWitness = Uint8Array;
+/** @internal */
+export type TapKeySig = Uint8Array;
+/** @internal */
+export type TapInternalKey = Uint8Array;
+/** @internal */
+export type TapMerkleRoot = Uint8Array;
+/** @internal */
+export interface TapScriptSig extends PartialSig {
+    leafHash: Uint8Array;
+}
+/** @internal */
+export interface TapLeafScript {
+    controlBlock: Uint8Array;
+    leafVersion: number;
+    script: Uint8Array;
+}
+/** @internal */
+export interface TapBip32Derivation extends Bip32Derivation {
+    leafHashes: Uint8Array[];
+}
+/** @internal */
+export interface PsbtInputUpdate {
+    partialSig?: PartialSig[];
+    nonWitnessUtxo?: NonWitnessUtxo;
+    witnessUtxo?: WitnessUtxo;
+    sighashType?: SighashType;
+    redeemScript?: RedeemScript;
+    witnessScript?: WitnessScript;
+    bip32Derivation?: Bip32Derivation[];
+    finalScriptSig?: FinalScriptSig;
+    finalScriptWitness?: FinalScriptWitness;
+    tapKeySig?: TapKeySig;
+    tapScriptSig?: TapScriptSig[];
+    tapLeafScript?: TapLeafScript[];
+    tapBip32Derivation?: TapBip32Derivation[];
+    tapInternalKey?: TapInternalKey;
+    tapMerkleRoot?: TapMerkleRoot;
+}
+/** @internal */
+export interface PsbtInput extends PsbtInputUpdate {
+    unknownKeyVals?: KeyValue[];
+}
+/** @internal */
+export interface PsbtInputExtended extends PsbtInput {
+    [index: string]: unknown;
+}
+/** @internal */
+export declare function checkForInput(inputs: PsbtInput[], inputIndex: number): PsbtInput;

package/dist/bip174.js

@@ -0,0 +1,12 @@
+"use strict";
+// Copyright (c) 2026 Jose-Luis Landabaso - https://bitcoinerlab.com
+// Distributed under the MIT software license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkForInput = checkForInput;
+/** @internal */
+function checkForInput(inputs, inputIndex) {
+    const input = inputs[inputIndex];
+    if (!input)
+        throw new Error(`No input #${inputIndex}`);
+    return input;
+}

package/dist/bitcoinLib.d.ts

@@ -0,0 +1,385 @@
+/**
+ * This module defines the BitcoinLib interface – the abstraction boundary
+ * between the descriptor library core and the underlying Bitcoin
+ * implementation (bitcoinjs-lib, @scure/btc-signer, or any other).
+ *
+ * Adapters implement this interface. The core library receives it via
+ * DescriptorsFactory and threads it through closures.
+ */
+import type { Network } from './networks';
+import type { PsbtInput } from './bip174';
+/**
+ * Structural signer interface accepted by this library for single-key signing.
+ *
+ * In practice, pass an object from
+ * {@link https://github.com/bitcoinjs/ecpair | `ecpair`} (bitcoinjs stack).
+ *
+ * Example (bitcoinjs stack):
+ * ```ts
+ * import * as ecc from '@bitcoinerlab/secp256k1';
+ * import { ECPairFactory } from 'ecpair';
+ *
+ * const ECPair = ECPairFactory(ecc);
+ * const signer = ECPair.fromWIF('L1...');
+ * ```
+ */
+export interface ECPairInterfaceLike {
+    publicKey: Uint8Array;
+    privateKey?: Uint8Array;
+    sign(hash: Uint8Array, lowR?: boolean): Uint8Array;
+    verify(hash: Uint8Array, signature: Uint8Array): boolean;
+    tweak(t: Uint8Array): ECPairInterfaceLike;
+    signSchnorr?(hash: Uint8Array): Uint8Array;
+    verifySchnorr?(hash: Uint8Array, signature: Uint8Array): boolean;
+}
+/**
+ * Full bitcoinjs ecpair-compatible interface.
+ *
+ * This is exposed only for factory return typing when the adapter is the
+ * native bitcoinjs stack. Internal code should continue using
+ * `ECPairInterfaceLike`.
+ */
+/** @internal */
+interface ECPairInterface extends ECPairInterfaceLike {
+    compressed: boolean;
+    network: Network;
+    lowR: boolean;
+    toWIF(): string;
+    signSchnorr(hash: Uint8Array): Uint8Array;
+    verifySchnorr(hash: Uint8Array, signature: Uint8Array): boolean;
+    tweak(t: Uint8Array): ECPairInterface;
+}
+/**
+ * Structural HD node interface accepted by this library.
+ *
+ * In practice, pass a node from
+ * {@link https://github.com/bitcoinjs/bip32 | `bip32`} (bitcoinjs stack).
+ *
+ * Example (bitcoinjs stack):
+ * ```ts
+ * import * as ecc from '@bitcoinerlab/secp256k1';
+ * import { BIP32Factory } from 'bip32';
+ *
+ * const BIP32 = BIP32Factory(ecc);
+ * const node = BIP32.fromSeed(seedBytes);
+ * ```
+ */
+export interface BIP32InterfaceLike {
+    publicKey: Uint8Array;
+    privateKey?: Uint8Array;
+    fingerprint: Uint8Array;
+    derive(index: number): BIP32InterfaceLike;
+    derivePath(path: string): BIP32InterfaceLike;
+    neutered(): BIP32InterfaceLike;
+    toBase58(): string;
+    sign(hash: Uint8Array): Uint8Array;
+    tweak(t: Uint8Array): Omit<ECPairInterfaceLike, 'tweak' | 'privateKey'>;
+}
+/**
+ * Full bitcoinjs bip32-compatible interface.
+ *
+ * This is exposed only for factory return typing when the adapter is the
+ * native bitcoinjs stack. Internal code should continue using
+ * `BIP32InterfaceLike`.
+ */
+/** @internal */
+interface BIP32Interface extends BIP32InterfaceLike {
+    chainCode: Uint8Array;
+    network: Network;
+    depth: number;
+    index: number;
+    parentFingerprint: number;
+    identifier: Uint8Array;
+    isNeutered(): boolean;
+    neutered(): BIP32Interface;
+    derive(index: number): BIP32Interface;
+    deriveHardened(index: number): BIP32Interface;
+    derivePath(path: string): BIP32Interface;
+    toWIF(): string;
+    tweak(t: Uint8Array): Omit<ECPairInterface, 'tweak' | 'privateKey'>;
+    lowR: boolean;
+    verify(hash: Uint8Array, signature: Uint8Array): boolean;
+    signSchnorr(hash: Uint8Array): Uint8Array;
+    verifySchnorr(hash: Uint8Array, signature: Uint8Array): boolean;
+}
+/**
+ * Structural subset of
+ * {@link https://github.com/paulmillr/scure-bip32 | `@scure/bip32` `HDKey`}.
+ *
+ * Use this when signing with the scure stack.
+ *
+ * Example (scure stack):
+ * ```ts
+ * import { HDKey } from '@scure/bip32';
+ *
+ * const masterNode = HDKey.fromMasterSeed(seedBytes);
+ * ```
+ */
+export interface ScureHDKeyLike {
+    publicKey: Uint8Array | null;
+    privateKey: Uint8Array | null;
+    fingerprint: number;
+    versions?: {
+        public: number;
+        private: number;
+    };
+    derive(path: string): ScureHDKeyLike;
+    deriveChild(index: number): ScureHDKeyLike;
+    sign(hash: Uint8Array): Uint8Array;
+    publicExtendedKey: string;
+    privateExtendedKey: string;
+}
+/**
+ * Internal key-factory shape used by this library.
+ *
+ * In user code, this usually corresponds to
+ * {@link https://github.com/bitcoinjs/ecpair | `ECPairFactory` output}.
+ * @internal
+ */
+export interface ECPairAPILike {
+    isPoint(maybePoint: unknown): boolean;
+    fromPublicKey(buffer: Uint8Array, options?: {
+        compressed?: boolean;
+        network?: Network;
+    }): ECPairInterfaceLike;
+    fromWIF(wifString: string, network?: Network | Network[]): ECPairInterfaceLike;
+}
+/** Full bitcoinjs ecpair-compatible API.
+ * @internal
+ */
+export interface ECPairAPI {
+    isPoint(maybePoint: unknown): boolean;
+    fromPrivateKey(buffer: Uint8Array, options?: {
+        compressed?: boolean;
+        network?: Network;
+    }): ECPairInterface;
+    fromPublicKey(buffer: Uint8Array, options?: {
+        compressed?: boolean;
+        network?: Network;
+    }): ECPairInterface;
+    makeRandom(options?: {
+        compressed?: boolean;
+        network?: Network;
+        rng?: (arg?: number) => Uint8Array;
+    }): ECPairInterface;
+    fromWIF(wifString: string, network?: Network | Network[]): ECPairInterface;
+}
+/**
+ * Internal HD-factory shape used by this library.
+ *
+ * In user code, this usually corresponds to
+ * {@link https://github.com/bitcoinjs/bip32 | `BIP32Factory` output}.
+ * @internal
+ */
+export interface BIP32APILike {
+    fromBase58(inString: string, network?: Network): BIP32InterfaceLike;
+}
+/** Full bitcoinjs bip32-compatible API.
+ * @internal
+ */
+export interface BIP32API {
+    fromSeed(seed: Uint8Array, network?: Network): BIP32Interface;
+    fromBase58(inString: string, network?: Network): BIP32Interface;
+    fromPublicKey(publicKey: Uint8Array, chainCode: Uint8Array, network?: Network): BIP32Interface;
+    fromPrivateKey(privateKey: Uint8Array, chainCode: Uint8Array, network?: Network): BIP32Interface;
+}
+/** @internal */
+export interface Payment {
+    output?: Uint8Array;
+    address?: string;
+    input?: Uint8Array;
+    witness?: Uint8Array[];
+    redeem?: Payment;
+    hash?: Uint8Array;
+    pubkey?: Uint8Array;
+    /** Taproot x-only internal pubkey (32 bytes). */
+    internalPubkey?: Uint8Array;
+    network?: Network;
+}
+/**
+ * Minimal PSBT interface consumed by this library.
+ *
+ * This is intentionally a bitcoinjs-compatible structural subset so raw
+ * `bitcoinjs-lib.Psbt` instances can be passed directly to public APIs.
+ * The scure adapter maps `@scure/btc-signer.Transaction` to this surface.
+ * @internal
+ */
+export interface PsbtTxInput {
+    hash: Uint8Array;
+    index: number;
+    sequence?: number;
+}
+/** @internal */
+export type PsbtLikeInputUpdate = Partial<PsbtInput>;
+/**
+ * Minimal interface compatible with bitcoinjs-lib Psbt.
+ *
+ * In user code, simply pass a concrete
+ * {@link https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/ts_src/psbt.ts | bitcoinjs-lib `Psbt`}.
+ *
+ * Example (bitcoinjs stack):
+ * ```ts
+ * import { Psbt, networks } from 'bitcoinjs-lib';
+ *
+ * const psbt = new Psbt({ network: networks.bitcoin });
+ * ```
+ *
+ * Notes:
+ * - This interface is structural and intentionally minimal.
+ * - Some nested fields use internal helper types (for docs bloat control).
+ */
+export interface PsbtLike {
+    addInput(input: PsbtInput): void;
+    addOutput(output: {
+        script: Uint8Array;
+        value: bigint;
+    }): void;
+    readonly inputCount: number;
+    readonly data: {
+        inputs: PsbtInput[];
+    };
+    readonly txInputs: PsbtTxInput[];
+    setLocktime(locktime: number): void;
+    readonly locktime: number;
+    signInput(index: number, signer: ECPairInterfaceLike): void;
+    signAllInputs(signer: ECPairInterfaceLike): void;
+    signInputHD(index: number, hdSigner: BIP32InterfaceLike): void;
+    signAllInputsHD(hdSigner: BIP32InterfaceLike): void;
+    finalizeInput(index: number, finalizer?: FinalScriptsFunc): void;
+    finalizeTaprootInput(index: number, tapLeafHashToFinalize: Uint8Array | undefined, finalizer: () => {
+        finalScriptWitness: Uint8Array;
+    }): void;
+    validateSignaturesOfInput(index: number, validator: (pubkey: Uint8Array, msghash: Uint8Array, signature: Uint8Array) => boolean): boolean;
+    updateInput(index: number, data: PsbtLikeInputUpdate): void;
+    toBase64(): string;
+}
+/** @internal */
+export type FinalScriptsFunc = (inputIndex: number, input: PsbtInput, script: Uint8Array, isSegwit: boolean, isP2SH: boolean, isP2WSH: boolean) => {
+    finalScriptSig: Uint8Array | undefined;
+    finalScriptWitness: Uint8Array | undefined;
+};
+/**
+ * Minimal interface compatible with @scure/btc-signer Transaction.
+ *
+ * In user code, simply pass a concrete
+ * {@link https://github.com/paulmillr/scure-btc-signer | `@scure/btc-signer` `Transaction`}.
+ *
+ * Example (scure stack):
+ * ```ts
+ * import { Transaction } from '@scure/btc-signer';
+ *
+ * const tx = new Transaction({ allowUnknownOutputs: true });
+ * ```
+ */
+export interface ScureTransactionLike {
+    inputsLength: number;
+    outputsLength: number;
+    getInput(index: number): unknown;
+    getOutput(index: number): unknown;
+    addInput(input: unknown): void;
+    addOutput(output: {
+        script: Uint8Array;
+        amount: bigint;
+    }): void;
+    sign(signer: unknown): number;
+    signIdx(signer: unknown, index: number): boolean;
+    finalize(): void;
+    finalizeIdx(index: number): void;
+    toPSBT(): Uint8Array;
+    lockTime: number;
+}
+/**
+ * Type guard to detect if a transaction object is a
+ * `@scure/btc-signer` `Transaction`.
+ * Checks for scure-specific properties that distinguish it from bitcoinjs-lib Psbt.
+ * @internal
+ */
+export declare function isScureTransaction(psbt: PsbtLike | ScureTransactionLike): psbt is ScureTransactionLike;
+/** @internal */
+export interface Transaction {
+    getId(): string;
+    outs: Array<{
+        script: Uint8Array;
+        value: bigint;
+    }>;
+    toBuffer(): Uint8Array;
+}
+/** @internal */
+export type Tapleaf = {
+    output: Uint8Array;
+    version?: number;
+};
+/** @internal */
+export type Taptree = [Taptree | Tapleaf, Taptree | Tapleaf] | Tapleaf;
+/**
+ * The complete Bitcoin backend adapter.
+ *
+ * Implementations wrap either bitcoinjs-lib or @scure/btc-signer.
+ * Received by `DescriptorsFactory` and threaded through the library.
+ * @internal
+ */
+export interface BitcoinLib {
+    payments: {
+        p2pk(a: {
+            pubkey: Uint8Array;
+            network?: Network;
+        }): Payment;
+        p2pkh(a: {
+            pubkey?: Uint8Array;
+            hash?: Uint8Array;
+            output?: Uint8Array;
+            network?: Network;
+        }): Payment;
+        p2sh(a: {
+            redeem?: Payment;
+            output?: Uint8Array;
+            network?: Network;
+        }): Payment;
+        p2wpkh(a: {
+            pubkey?: Uint8Array;
+            hash?: Uint8Array;
+            output?: Uint8Array;
+            network?: Network;
+        }): Payment;
+        p2wsh(a: {
+            redeem?: Payment;
+            output?: Uint8Array;
+            network?: Network;
+        }): Payment;
+        p2ms(a: {
+            m: number;
+            pubkeys: Uint8Array[];
+            network?: Network;
+        }): Payment;
+        p2tr(a: {
+            internalPubkey?: Uint8Array;
+            scriptTree?: Taptree;
+            redeem?: {
+                output: Uint8Array;
+                redeemVersion?: number;
+            };
+            output?: Uint8Array;
+            network?: Network;
+        }): Payment;
+    };
+    script: {
+        fromASM(asm: string): Uint8Array;
+        toStack(scriptBuf: Uint8Array): Uint8Array[];
+        decompile(scriptBuf: Uint8Array): Array<number | Uint8Array> | null;
+        countNonPushOnlyOPs(chunks: Array<number | Uint8Array>): number;
+        number: {
+            encode(n: number): Uint8Array;
+        };
+    };
+    Transaction: {
+        fromHex(hex: string): Transaction;
+        fromBuffer(buf: Uint8Array): Transaction;
+    };
+    address: {
+        toOutputScript(addr: string, network?: Network): Uint8Array;
+    };
+    ECPair: ECPairAPILike;
+    BIP32: BIP32APILike;
+    verifySchnorr(msghash: Uint8Array, pubkey: Uint8Array, signature: Uint8Array): boolean;
+}
+export {};

package/dist/bitcoinLib.js

@@ -0,0 +1,19 @@
+"use strict";
+// Copyright (c) 2026 Jose-Luis Landabaso - https://bitcoinerlab.com
+// Distributed under the MIT software license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isScureTransaction = isScureTransaction;
+/**
+ * Type guard to detect if a transaction object is a
+ * `@scure/btc-signer` `Transaction`.
+ * Checks for scure-specific properties that distinguish it from bitcoinjs-lib Psbt.
+ * @internal
+ */
+function isScureTransaction(psbt) {
+    const candidate = psbt;
+    return ('inputsLength' in candidate &&
+        'outputsLength' in candidate &&
+        'toPSBT' in candidate &&
+        typeof candidate.toPSBT === 'function' &&
+        'lockTime' in candidate);
+}

package/dist/bitcoinjs-lib-internals.d.ts

@@ -0,0 +1,6 @@
+import type { PsbtInput } from './bip174';
+import { type Tapleaf } from './bitcoinLib';
+export declare function tapleafHash(leaf: Tapleaf): Uint8Array;
+export declare function tapTweakHash(pubKey: Uint8Array, h?: Uint8Array): Uint8Array;
+export declare function witnessStackToScriptWitness(witness: Uint8Array[]): Uint8Array;
+export declare function isTaprootInput(input: PsbtInput | undefined): boolean;