@bitcoinerlab/descriptors-core 3.1.0

package/dist/adapters/applyPR2137.d.ts

@@ -0,0 +1,2 @@
+import type { Psbt } from 'bitcoinjs-lib';
+export declare const applyPR2137: (psbt: Psbt) => void;

package/dist/adapters/applyPR2137.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyPR2137 = void 0;
+const bip174_1 = require("../bip174");
+const bitcoinjs_lib_internals_1 = require("../bitcoinjs-lib-internals");
+const crypto_1 = require("../crypto");
+const uint8array_tools_1 = require("uint8array-tools");
+const toXOnly = (pubKey) => pubKey.length === 32 ? pubKey : pubKey.slice(1, 33);
+function range(n) {
+    return [...Array(n).keys()];
+}
+function tapBranchHash(a, b) {
+    return (0, crypto_1.taggedHash)('TapBranch', (0, uint8array_tools_1.concat)([a, b]));
+}
+function calculateScriptTreeMerkleRoot(leafHashes) {
+    if (!leafHashes || leafHashes.length === 0) {
+        return undefined;
+    }
+    const leafHashCopies = leafHashes.map(leafHash => Uint8Array.from(leafHash));
+    // sort the leaf nodes
+    leafHashCopies.sort(uint8array_tools_1.compare);
+    // create the initial hash node
+    let currentLevel = leafHashCopies;
+    // build Merkle Tree
+    while (currentLevel.length > 1) {
+        const nextLevel = [];
+        for (let i = 0; i < currentLevel.length; i += 2) {
+            const left = currentLevel[i];
+            if (!left)
+                throw new Error('Invalid tapleaf hash tree level');
+            const right = i + 1 < currentLevel.length ? (currentLevel[i + 1] ?? left) : left;
+            nextLevel.push(i + 1 < currentLevel.length ? tapBranchHash(left, right) : left);
+        }
+        currentLevel = nextLevel;
+    }
+    return currentLevel[0];
+}
+function getTweakSignersFromHD(inputIndex, inputs, hdKeyPair) {
+    const input = (0, bip174_1.checkForInput)(inputs, inputIndex);
+    if (!input.tapBip32Derivation || input.tapBip32Derivation.length === 0) {
+        throw new Error('Need tapBip32Derivation to sign with HD');
+    }
+    const myDerivations = input.tapBip32Derivation
+        .map(bipDv => {
+        if ((0, uint8array_tools_1.compare)(bipDv.masterFingerprint, hdKeyPair.fingerprint) === 0) {
+            return bipDv;
+        }
+        else {
+            return;
+        }
+    })
+        .filter(v => !!v);
+    if (myDerivations.length === 0) {
+        throw new Error('Need one tapBip32Derivation masterFingerprint to match the HDSigner fingerprint');
+    }
+    const signers = myDerivations.map(bipDv => {
+        const node = hdKeyPair.derivePath(bipDv.path);
+        if ((0, uint8array_tools_1.compare)(bipDv.pubkey, toXOnly(node.publicKey)) !== 0) {
+            throw new Error('pubkey did not match tapBip32Derivation');
+        }
+        //FIX BITCOINERLAB:
+        //The 3 lines below detect script-path spends and disable key-path tweaking.
+        //Reasoning:
+        //- In Taproot, key-path spends require tweaking the internal key.
+        //- Script-path spends MUST NOT tweak the key; signatures use the raw internal key.
+        const input = inputs[inputIndex];
+        if (!input)
+            throw new Error('could not find the input');
+        if (input.tapLeafScript && input.tapLeafScript.length > 0)
+            return node;
+        const h = calculateScriptTreeMerkleRoot(bipDv.leafHashes);
+        const tweakValue = (0, bitcoinjs_lib_internals_1.tapTweakHash)(toXOnly(node.publicKey), h);
+        return node.tweak(tweakValue);
+    });
+    return signers;
+}
+function getSignersFromHD(inputIndex, inputs, hdKeyPair) {
+    const input = (0, bip174_1.checkForInput)(inputs, inputIndex);
+    if ((0, bitcoinjs_lib_internals_1.isTaprootInput)(input)) {
+        return getTweakSignersFromHD(inputIndex, inputs, hdKeyPair);
+    }
+    if (!input.bip32Derivation || input.bip32Derivation.length === 0) {
+        throw new Error('Need bip32Derivation to sign with HD');
+    }
+    const myDerivations = input.bip32Derivation
+        .map(bipDv => {
+        if ((0, uint8array_tools_1.compare)(bipDv.masterFingerprint, hdKeyPair.fingerprint) === 0) {
+            return bipDv;
+        }
+        else {
+            return;
+        }
+    })
+        .filter(v => !!v);
+    if (myDerivations.length === 0) {
+        throw new Error('Need one bip32Derivation masterFingerprint to match the HDSigner fingerprint');
+    }
+    const signers = myDerivations.map(bipDv => {
+        const node = hdKeyPair.derivePath(bipDv.path);
+        if ((0, uint8array_tools_1.compare)(bipDv.pubkey, node.publicKey) !== 0) {
+            throw new Error('pubkey did not match bip32Derivation');
+        }
+        return node;
+    });
+    return signers;
+}
+const applyPR2137 = (psbt) => {
+    psbt.signInputHD = function signInputHD(inputIndex, hdKeyPair, sighashTypes) {
+        if (!hdKeyPair || !hdKeyPair.publicKey || !hdKeyPair.fingerprint) {
+            throw new Error('Need HDSigner to sign input');
+        }
+        const signers = getSignersFromHD(inputIndex, this.data.inputs, hdKeyPair);
+        const results = [];
+        for (const signer of signers) {
+            try {
+                this.signInput(inputIndex, signer, sighashTypes);
+                results.push(true);
+            }
+            catch (err) {
+                void err;
+                results.push(false);
+            }
+        }
+        if (results.every(v => v === false)) {
+            throw new Error('No inputs were signed');
+        }
+        return this;
+    };
+    psbt.signAllInputsHD = function signAllInputsHD(hdKeyPair, sighashTypes) {
+        if (!hdKeyPair || !hdKeyPair.publicKey || !hdKeyPair.fingerprint) {
+            throw new Error('Need HDSigner to sign input');
+        }
+        const results = [];
+        for (const i of range(psbt.data.inputs.length)) {
+            try {
+                psbt.signInputHD(i, hdKeyPair, sighashTypes);
+                results.push(true);
+            }
+            catch (err) {
+                void err;
+                results.push(false);
+            }
+        }
+        if (results.every(v => v === false)) {
+            throw new Error('No inputs were signed');
+        }
+        return psbt;
+    };
+};
+exports.applyPR2137 = applyPR2137;

package/dist/adapters/bitcoinjs.d.ts

@@ -0,0 +1,8 @@
+import type { TinySecp256k1Interface } from '../types';
+import type { BitcoinLib } from '../bitcoinLib';
+/**
+ * Create a BitcoinLib backed by bitcoinjs-lib.
+ *
+ * @param ecc  A TinySecp256k1Interface (e.g. `@bitcoinerlab/secp256k1`).
+ */
+export declare function createBitcoinjsLib(ecc: TinySecp256k1Interface): BitcoinLib;

package/dist/adapters/bitcoinjs.js

@@ -0,0 +1,36 @@
+"use strict";
+// Copyright (c) 2026 Jose-Luis Landabaso - https://bitcoinerlab.com
+// Distributed under the MIT software license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBitcoinjsLib = createBitcoinjsLib;
+/**
+ * bitcoinjs-lib adapter for BitcoinLib.
+ *
+ * Wraps bitcoinjs-lib, ecpair, bip32 and related packages into the
+ * BitcoinLib interface.  This is the default backend and should produce
+ * identical behaviour to the pre-refactor library.
+ */
+const bitcoinjs_lib_1 = require("bitcoinjs-lib");
+const bip32_1 = require("bip32");
+const ecpair_1 = require("ecpair");
+/**
+ * Create a BitcoinLib backed by bitcoinjs-lib.
+ *
+ * @param ecc  A TinySecp256k1Interface (e.g. `@bitcoinerlab/secp256k1`).
+ */
+function createBitcoinjsLib(ecc) {
+    (0, bitcoinjs_lib_1.initEccLib)(ecc);
+    const ECPair = (0, ecpair_1.ECPairFactory)(ecc);
+    const BIP32 = (0, bip32_1.BIP32Factory)(ecc);
+    if (!ecc.verifySchnorr)
+        throw new Error('TinySecp256k1Interface is not initialized properly: verifySchnorr is missing.');
+    return {
+        payments: bitcoinjs_lib_1.payments,
+        script: bitcoinjs_lib_1.script,
+        Transaction: bitcoinjs_lib_1.Transaction,
+        address: bitcoinjs_lib_1.address,
+        ECPair,
+        BIP32,
+        verifySchnorr: ecc.verifySchnorr
+    };
+}

package/dist/adapters/scure/address.d.ts

@@ -0,0 +1,2 @@
+import type { BitcoinLib } from '../../bitcoinLib';
+export declare function createScureAddressAdapter(): BitcoinLib['address'];

package/dist/adapters/scure/address.js

@@ -0,0 +1,50 @@
+"use strict";
+// Copyright (c) 2026 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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createScureAddressAdapter = createScureAddressAdapter;
+const btc = __importStar(require("@scure/btc-signer"));
+const networks_1 = require("../../networks");
+const common_1 = require("./common");
+function createScureAddressAdapter() {
+    return {
+        toOutputScript(addr, network) {
+            const net = (0, common_1.toBtcSignerNetwork)(network ?? networks_1.networks.bitcoin);
+            const decoded = btc.Address(net).decode(addr);
+            return btc.OutScript.encode(decoded);
+        }
+    };
+}

package/dist/adapters/scure/bip32.d.ts

@@ -0,0 +1,2 @@
+import type { BitcoinLib } from '../../bitcoinLib';
+export declare function createScureBIP32Adapter(): BitcoinLib['BIP32'];

package/dist/adapters/scure/bip32.js

@@ -0,0 +1,16 @@
+"use strict";
+// Copyright (c) 2026 Jose-Luis Landabaso - https://bitcoinerlab.com
+// Distributed under the MIT software license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createScureBIP32Adapter = createScureBIP32Adapter;
+const bip32_1 = require("@scure/bip32");
+const scureKeys_1 = require("../scureKeys");
+const common_1 = require("./common");
+function createScureBIP32Adapter() {
+    return {
+        fromBase58(inString, network) {
+            const hd = bip32_1.HDKey.fromExtendedKey(inString, (0, common_1.scureVersions)(network));
+            return (0, scureKeys_1.wrapScureHDKey)(hd);
+        }
+    };
+}

package/dist/adapters/scure/common.d.ts

@@ -0,0 +1,14 @@
+import { type Network } from '../../networks';
+/** Convert our Network to the format expected by @scure/btc-signer */
+export declare function toBtcSignerNetwork(network: Network): {
+    bech32: string;
+    pubKeyHash: number;
+    scriptHash: number;
+    wif: number;
+};
+export declare function scureVersions(network?: Network): {
+    public: number;
+    private: number;
+};
+export declare function uint32ToBytesBE(value: number): Uint8Array;
+export declare function uint32FromBytesBE(bytes: Uint8Array): number;

package/dist/adapters/scure/common.js

@@ -0,0 +1,36 @@
+"use strict";
+// Copyright (c) 2026 Jose-Luis Landabaso - https://bitcoinerlab.com
+// Distributed under the MIT software license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBtcSignerNetwork = toBtcSignerNetwork;
+exports.scureVersions = scureVersions;
+exports.uint32ToBytesBE = uint32ToBytesBE;
+exports.uint32FromBytesBE = uint32FromBytesBE;
+const networks_1 = require("../../networks");
+const uint8array_tools_1 = require("uint8array-tools");
+/** Convert our Network to the format expected by @scure/btc-signer */
+function toBtcSignerNetwork(network) {
+    return {
+        bech32: network.bech32,
+        pubKeyHash: network.pubKeyHash,
+        scriptHash: network.scriptHash,
+        wif: network.wif
+    };
+}
+function scureVersions(network) {
+    const net = network ?? networks_1.networks.bitcoin;
+    return {
+        public: net.bip32.public,
+        private: net.bip32.private
+    };
+}
+function uint32ToBytesBE(value) {
+    const bytes = new Uint8Array(4);
+    (0, uint8array_tools_1.writeUInt32)(bytes, 0, value, 'BE');
+    return bytes;
+}
+function uint32FromBytesBE(bytes) {
+    if (bytes.length !== 4)
+        throw new Error('Expected 4-byte fingerprint');
+    return (0, uint8array_tools_1.readUInt32)(bytes, 0, 'BE');
+}

package/dist/adapters/scure/ecpair.d.ts

@@ -0,0 +1,2 @@
+import type { BitcoinLib } from '../../bitcoinLib';
+export declare function createScureECPairAdapter(): BitcoinLib['ECPair'];

package/dist/adapters/scure/ecpair.js

@@ -0,0 +1,58 @@
+"use strict";
+// Copyright (c) 2026 Jose-Luis Landabaso - https://bitcoinerlab.com
+// Distributed under the MIT software license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createScureECPairAdapter = createScureECPairAdapter;
+const base_1 = require("@scure/base");
+const secp256k1_js_1 = require("@noble/curves/secp256k1.js");
+const uint8array_tools_1 = require("uint8array-tools");
+const crypto_1 = require("../../crypto");
+const scureKeys_1 = require("../scureKeys");
+function decodeWIF(wifString, network) {
+    const raw = base_1.base58.decode(wifString);
+    if (!(raw.length === 37 || raw.length === 38)) {
+        throw new Error('Wrong WIF length');
+    }
+    const payload = raw.slice(0, raw.length - 4);
+    const checksum = raw.slice(raw.length - 4);
+    const expected = (0, crypto_1.sha256)((0, crypto_1.sha256)(payload)).slice(0, 4);
+    if ((0, uint8array_tools_1.compare)(checksum, expected) !== 0) {
+        throw new Error('Invalid WIF checksum');
+    }
+    const version = payload[0];
+    if (version === undefined)
+        throw new Error('Invalid WIF payload');
+    if (Array.isArray(network)) {
+        if (!network.some(net => net.wif === version)) {
+            throw new Error('Invalid network version');
+        }
+    }
+    else if (network && network.wif !== version) {
+        throw new Error('Invalid network version');
+    }
+    if (!(payload.length === 33 || payload.length === 34)) {
+        throw new Error('Wrong WIF length');
+    }
+    if (payload.length === 34 && payload[33] !== 0x01) {
+        throw new Error('Invalid WIF compression flag');
+    }
+    return {
+        privateKey: payload.slice(1, 33),
+        compressed: payload.length === 34
+    };
+}
+function createScureECPairAdapter() {
+    return {
+        isPoint(maybePoint) {
+            return (maybePoint instanceof Uint8Array &&
+                secp256k1_js_1.secp256k1.utils.isValidPublicKey(maybePoint));
+        },
+        fromPublicKey(buffer, _options) {
+            return (0, scureKeys_1.wrapScurePublicKey)(buffer);
+        },
+        fromWIF(wifString, network) {
+            const { privateKey, compressed } = decodeWIF(wifString, network);
+            return (0, scureKeys_1.wrapScurePrivateKey)(privateKey, compressed);
+        }
+    };
+}

package/dist/adapters/scure/payments.d.ts

@@ -0,0 +1,2 @@
+import type { BitcoinLib } from '../../bitcoinLib';
+export declare function createScurePaymentsAdapter(): BitcoinLib['payments'];

package/dist/adapters/scure/payments.js

@@ -0,0 +1,216 @@
+"use strict";
+// Copyright (c) 2026 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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createScurePaymentsAdapter = createScurePaymentsAdapter;
+const btc = __importStar(require("@scure/btc-signer"));
+const uint8array_tools_1 = require("uint8array-tools");
+const networks_1 = require("../../networks");
+const common_1 = require("./common");
+const script_1 = require("./script");
+function convertTaptree(tree) {
+    if (Array.isArray(tree))
+        return [convertTaptree(tree[0]), convertTaptree(tree[1])];
+    return { script: tree.output, leafVersion: tree.version ?? 0xc0 };
+}
+function decodeOutputWithAddress(output, expectedType, net) {
+    const decoded = btc.OutScript.decode(output);
+    if (decoded.type !== expectedType)
+        return undefined;
+    return { output, address: btc.Address(net).encode(decoded) };
+}
+function createScurePaymentsAdapter() {
+    return {
+        p2pk(a) {
+            if (!a.pubkey)
+                throw new Error('p2pk requires pubkey');
+            const net = (0, common_1.toBtcSignerNetwork)(a.network ?? networks_1.networks.bitcoin);
+            const result = btc.p2pk(a.pubkey, net);
+            return { output: result.script, pubkey: a.pubkey };
+        },
+        p2pkh(a) {
+            const net = (0, common_1.toBtcSignerNetwork)(a.network ?? networks_1.networks.bitcoin);
+            if (a.pubkey) {
+                const result = btc.p2pkh(a.pubkey, net);
+                return {
+                    output: result.script,
+                    address: result.address,
+                    pubkey: a.pubkey
+                };
+            }
+            if (a.hash)
+                throw new Error('p2pkh({ hash }) is not supported in the scure adapter. Use pubkey or output.');
+            if (a.output) {
+                const payment = decodeOutputWithAddress(a.output, 'pkh', net);
+                if (payment)
+                    return payment;
+            }
+            throw new Error('p2pkh requires pubkey or output');
+        },
+        p2sh(a) {
+            if (a.network && a.redeem?.network && a.network !== a.redeem.network)
+                throw new TypeError('Network mismatch');
+            const net = (0, common_1.toBtcSignerNetwork)(a.network ?? a.redeem?.network ?? networks_1.networks.bitcoin);
+            if (a.redeem?.output) {
+                const innerScript = a.redeem.output;
+                if (innerScript.length > 520) {
+                    throw new Error('Redeem.output unspendable if larger than 520 bytes');
+                }
+                const input = btc.Script.encode(a.redeem.input
+                    ? [...(0, script_1.toStack)(a.redeem.input), innerScript]
+                    : [innerScript]);
+                const result = btc.p2sh({ type: 'unknown', script: innerScript }, net);
+                const payment = {
+                    output: result.script,
+                    address: result.address,
+                    redeem: { ...a.redeem, output: innerScript },
+                    input
+                };
+                if (a.redeem.witness)
+                    payment.witness = a.redeem.witness;
+                return payment;
+            }
+            if (a.output) {
+                const payment = decodeOutputWithAddress(a.output, 'sh', net);
+                if (payment)
+                    return payment;
+            }
+            throw new Error('p2sh requires redeem.output or output');
+        },
+        p2wpkh(a) {
+            const net = (0, common_1.toBtcSignerNetwork)(a.network ?? networks_1.networks.bitcoin);
+            if (a.pubkey) {
+                const result = btc.p2wpkh(a.pubkey, net);
+                return {
+                    output: result.script,
+                    address: result.address,
+                    pubkey: a.pubkey
+                };
+            }
+            if (a.hash)
+                throw new Error('p2wpkh({ hash }) is not supported in the scure adapter. Use pubkey or output.');
+            if (a.output) {
+                const payment = decodeOutputWithAddress(a.output, 'wpkh', net);
+                if (payment)
+                    return payment;
+            }
+            throw new Error('p2wpkh requires pubkey or output');
+        },
+        p2wsh(a) {
+            if (a.network && a.redeem?.network && a.network !== a.redeem.network)
+                throw new TypeError('Network mismatch');
+            const net = (0, common_1.toBtcSignerNetwork)(a.network ?? a.redeem?.network ?? networks_1.networks.bitcoin);
+            if (a.redeem?.output) {
+                const innerScript = a.redeem.output;
+                const witness = a.redeem.input
+                    ? [...(0, script_1.toStack)(a.redeem.input), innerScript]
+                    : a.redeem.witness
+                        ? [...a.redeem.witness, innerScript]
+                        : undefined;
+                const result = btc.p2wsh({ type: 'unknown', script: innerScript }, net);
+                const payment = {
+                    output: result.script,
+                    address: result.address,
+                    redeem: {
+                        ...a.redeem,
+                        output: innerScript,
+                        input: new Uint8Array(0)
+                    },
+                    input: new Uint8Array(0)
+                };
+                if (witness)
+                    payment.witness = witness;
+                return payment;
+            }
+            if (a.output) {
+                const payment = decodeOutputWithAddress(a.output, 'wsh', net);
+                if (payment)
+                    return payment;
+            }
+            throw new Error('p2wsh requires redeem.output or output');
+        },
+        p2ms(a) {
+            const result = btc.p2ms(a.m, a.pubkeys);
+            return { output: result.script };
+        },
+        p2tr(a) {
+            const net = (0, common_1.toBtcSignerNetwork)(a.network ?? networks_1.networks.bitcoin);
+            if (a.internalPubkey) {
+                if (a.scriptTree) {
+                    const scriptTree = convertTaptree(a.scriptTree);
+                    const treeResult = btc.p2tr(a.internalPubkey, scriptTree, net, true);
+                    const payment = {
+                        output: treeResult.script,
+                        address: treeResult.address,
+                        internalPubkey: a.internalPubkey,
+                        pubkey: treeResult.tweakedPubkey
+                    };
+                    if (a.redeem?.output) {
+                        const redeemVersion = a.redeem.redeemVersion ?? 0xc0;
+                        for (const [controlBlock, scriptWithVersion] of treeResult.tapLeafScript ?? []) {
+                            const leafVersion = scriptWithVersion[scriptWithVersion.length - 1] ?? 0xc0;
+                            const leafScript = scriptWithVersion.subarray(0, -1);
+                            if ((0, uint8array_tools_1.compare)(leafScript, a.redeem.output) === 0 &&
+                                leafVersion === redeemVersion) {
+                                payment.witness = [
+                                    leafScript,
+                                    btc.TaprootControlBlock.encode(controlBlock)
+                                ];
+                                break;
+                            }
+                        }
+                    }
+                    return payment;
+                }
+                const keyResult = btc.p2tr(a.internalPubkey, undefined, net);
+                return {
+                    output: keyResult.script,
+                    address: keyResult.address,
+                    internalPubkey: a.internalPubkey,
+                    pubkey: keyResult.tweakedPubkey
+                };
+            }
+            if (a.output) {
+                const decoded = btc.OutScript.decode(a.output);
+                if (decoded.type === 'tr') {
+                    const address = btc.Address(net).encode(decoded);
+                    return { output: a.output, address, pubkey: decoded.pubkey };
+                }
+            }
+            throw new Error('p2tr requires internalPubkey or output');
+        }
+    };
+}

package/dist/adapters/scure/psbt.d.ts

@@ -0,0 +1,43 @@
+import * as btc from '@scure/btc-signer';
+import type { BIP32InterfaceLike, FinalScriptsFunc, PsbtLike, PsbtLikeInputUpdate, PsbtTxInput } from '../../bitcoinLib';
+import type { PsbtInput } from '../../bip174';
+interface SignerWithPrivateKey {
+    publicKey: Uint8Array;
+    sign(hash: Uint8Array): Uint8Array;
+    privateKey?: Uint8Array;
+}
+declare class ScurePsbtAdapter implements PsbtLike {
+    #private;
+    constructor(tx: btc.Transaction);
+    get raw(): btc.Transaction;
+    addInput(input: PsbtInput & Partial<PsbtTxInput>): void;
+    addOutput(output: {
+        script: Uint8Array;
+        value: bigint;
+    }): void;
+    get inputCount(): number;
+    get data(): {
+        inputs: Partial<PsbtInput>[];
+    };
+    get txInputs(): {
+        hash: Uint8Array<ArrayBuffer>;
+        index: number;
+        sequence: number;
+    }[];
+    setLocktime(locktime: number): void;
+    get locktime(): number;
+    signInput(index: number, signer: SignerWithPrivateKey): void;
+    signAllInputs(signer: SignerWithPrivateKey): 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;
+}
+/** Wrap a raw @scure/btc-signer Transaction into a PsbtLike adapter. */
+export declare function wrapScureTransaction(transaction: btc.Transaction): ScurePsbtAdapter;
+export {};