@bitcoinerlab/descriptors-core 3.1.0

package/dist/adapters/scure/psbt.js

@@ -0,0 +1,382 @@
+"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;
+    };
+})();
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ScurePsbtAdapter_tx;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapScureTransaction = wrapScureTransaction;
+const btc = __importStar(require("@scure/btc-signer"));
+const base_1 = require("@scure/base");
+const script_js_1 = require("@scure/btc-signer/script.js");
+const uint8array_tools_1 = require("uint8array-tools");
+const common_1 = require("./common");
+let warnedAboutScureSignatureValidation = false;
+function copyDefinedFields(source, target, keys) {
+    for (const key of keys) {
+        const value = source[key];
+        if (value !== undefined)
+            target[key] = source[key];
+    }
+}
+function pathArrayToString(path) {
+    if (path.length === 0)
+        return 'm';
+    const parts = path.map(idx => {
+        if (idx >= 0x80000000)
+            return `${idx - 0x80000000}'`;
+        return `${idx}`;
+    });
+    return `m/${parts.join('/')}`;
+}
+function toScureInputUpdate(input) {
+    const result = {};
+    copyDefinedFields(input, result, [
+        'nonWitnessUtxo',
+        'redeemScript',
+        'witnessScript',
+        'tapInternalKey',
+        'tapMerkleRoot',
+        'tapKeySig',
+        'sighashType',
+        'finalScriptSig'
+    ]);
+    if (input.witnessUtxo)
+        result.witnessUtxo = {
+            script: input.witnessUtxo.script,
+            amount: input.witnessUtxo.value
+        };
+    if (input.bip32Derivation)
+        result.bip32Derivation = input.bip32Derivation.map(({ pubkey, masterFingerprint, path }) => [
+            pubkey,
+            {
+                fingerprint: (0, common_1.uint32FromBytesBE)(masterFingerprint),
+                path: btc.bip32Path(path)
+            }
+        ]);
+    if (input.tapBip32Derivation)
+        result.tapBip32Derivation = input.tapBip32Derivation.map(({ pubkey, masterFingerprint, path, leafHashes }) => [
+            pubkey,
+            {
+                hashes: leafHashes,
+                der: {
+                    fingerprint: (0, common_1.uint32FromBytesBE)(masterFingerprint),
+                    path: btc.bip32Path(path)
+                }
+            }
+        ]);
+    if (input.partialSig)
+        result.partialSig = input.partialSig.map(({ pubkey, signature }) => [
+            pubkey,
+            signature
+        ]);
+    if (input.tapLeafScript)
+        result.tapLeafScript = input.tapLeafScript.map(leaf => {
+            const decoded = btc.TaprootControlBlock.decode(leaf.controlBlock);
+            const controlBlock = {
+                ...decoded,
+                version: (decoded.version & 1) | leaf.leafVersion
+            };
+            return [
+                controlBlock,
+                (0, uint8array_tools_1.concat)([leaf.script, Uint8Array.from([leaf.leafVersion])])
+            ];
+        });
+    if (input.tapScriptSig)
+        result.tapScriptSig = input.tapScriptSig.map(sig => [
+            { pubKey: sig.pubkey, leafHash: sig.leafHash },
+            sig.signature
+        ]);
+    if (input.finalScriptWitness)
+        result.finalScriptWitness = script_js_1.RawWitness.decode(input.finalScriptWitness);
+    return result;
+}
+function scureInputToBitcoinjs(raw) {
+    const input = {};
+    copyDefinedFields(raw, input, [
+        'redeemScript',
+        'witnessScript',
+        'tapInternalKey',
+        'tapMerkleRoot',
+        'tapKeySig',
+        'sighashType',
+        'finalScriptSig'
+    ]);
+    if (raw.nonWitnessUtxo)
+        input.nonWitnessUtxo = script_js_1.RawTx.encode(raw.nonWitnessUtxo);
+    if (raw.witnessUtxo)
+        input.witnessUtxo = {
+            script: raw.witnessUtxo.script,
+            value: raw.witnessUtxo.amount
+        };
+    if (raw.bip32Derivation)
+        input.bip32Derivation = raw.bip32Derivation.map(([pubkey, { fingerprint, path }]) => ({
+            pubkey,
+            masterFingerprint: (0, common_1.uint32ToBytesBE)(fingerprint),
+            path: pathArrayToString(path)
+        }));
+    if (raw.tapBip32Derivation)
+        input.tapBip32Derivation = raw.tapBip32Derivation.map(([pubkey, { hashes, der }]) => ({
+            pubkey,
+            masterFingerprint: (0, common_1.uint32ToBytesBE)(der.fingerprint),
+            path: pathArrayToString(der.path),
+            leafHashes: hashes
+        }));
+    if (raw.partialSig)
+        input.partialSig = raw.partialSig.map(([pubkey, signature]) => ({
+            pubkey,
+            signature
+        }));
+    if (raw.tapLeafScript)
+        input.tapLeafScript = raw.tapLeafScript.map(([controlBlock, scriptWithVersion]) => ({
+            controlBlock: btc.TaprootControlBlock.encode(controlBlock),
+            script: scriptWithVersion.subarray(0, -1),
+            leafVersion: scriptWithVersion[scriptWithVersion.length - 1] ?? 0xc0
+        }));
+    if (raw.tapScriptSig)
+        input.tapScriptSig = raw.tapScriptSig.map(([key, signature]) => ({
+            pubkey: key.pubKey,
+            leafHash: key.leafHash,
+            signature
+        }));
+    if (raw.finalScriptWitness)
+        input.finalScriptWitness = script_js_1.RawWitness.encode(raw.finalScriptWitness);
+    return input;
+}
+function requirePrivateKey(signer) {
+    if (!signer.privateKey)
+        throw new Error('Error: signer must expose a privateKey for scure signing');
+    return signer.privateKey;
+}
+function toScureHDKey(hdSigner) {
+    if (!hdSigner.privateKey)
+        throw new Error('Error: HD signer must expose a privateKey for scure signing');
+    return {
+        publicKey: hdSigner.publicKey,
+        privateKey: hdSigner.privateKey,
+        fingerprint: hdSigner.fingerprint instanceof Uint8Array
+            ? (0, common_1.uint32FromBytesBE)(hdSigner.fingerprint)
+            : hdSigner.fingerprint,
+        derive(path) {
+            return toScureHDKey(hdSigner.derivePath(path));
+        },
+        deriveChild(index) {
+            return toScureHDKey(hdSigner.derive(index));
+        },
+        sign: hdSigner.sign.bind(hdSigner)
+    };
+}
+class ScurePsbtAdapter {
+    constructor(tx) {
+        _ScurePsbtAdapter_tx.set(this, void 0);
+        __classPrivateFieldSet(this, _ScurePsbtAdapter_tx, tx, "f");
+    }
+    get raw() {
+        return __classPrivateFieldGet(this, _ScurePsbtAdapter_tx, "f");
+    }
+    addInput(input) {
+        if (!input.hash)
+            throw new Error('PSBT input hash is required');
+        if (input.index === undefined)
+            throw new Error('PSBT input index is required');
+        const scureInput = toScureInputUpdate(input);
+        // bitcoinjs stores input hash little-endian; scure expects txid order.
+        scureInput.txid = Uint8Array.from(input.hash).reverse();
+        scureInput.index = input.index;
+        if (input.sequence !== undefined)
+            scureInput.sequence = input.sequence;
+        __classPrivateFieldGet(this, _ScurePsbtAdapter_tx, "f").addInput(scureInput);
+    }
+    addOutput(output) {
+        __classPrivateFieldGet(this, _ScurePsbtAdapter_tx, "f").addOutput({ script: output.script, amount: output.value });
+    }
+    get inputCount() {
+        return __classPrivateFieldGet(this, _ScurePsbtAdapter_tx, "f").inputsLength;
+    }
+    get data() {
+        return {
+            inputs: Array.from({ length: __classPrivateFieldGet(this, _ScurePsbtAdapter_tx, "f").inputsLength }, (_value, index) => scureInputToBitcoinjs(__classPrivateFieldGet(this, _ScurePsbtAdapter_tx, "f").getInput(index)))
+        };
+    }
+    get txInputs() {
+        return Array.from({ length: __classPrivateFieldGet(this, _ScurePsbtAdapter_tx, "f").inputsLength }, (_value, index) => {
+            const raw = __classPrivateFieldGet(this, _ScurePsbtAdapter_tx, "f").getInput(index);
+            if (!raw.txid)
+                throw new Error(`PSBT input ${index} missing txid`);
+            if (raw.index === undefined)
+                throw new Error(`PSBT input ${index} missing index`);
+            return {
+                // scure keeps txid in natural order; bitcoinjs txInputs.hash uses LE.
+                hash: Uint8Array.from(raw.txid).reverse(),
+                index: raw.index,
+                sequence: raw.sequence ?? 0xffffffff
+            };
+        });
+    }
+    setLocktime(locktime) {
+        if (!Number.isSafeInteger(locktime) ||
+            locktime < 0 ||
+            locktime > 0xffffffff)
+            throw new Error('Error: locktime must be a uint32');
+        const mutableTx = __classPrivateFieldGet(this, _ScurePsbtAdapter_tx, "f");
+        if (!mutableTx.global || typeof mutableTx.global !== 'object')
+            throw new Error('Error: @scure/btc-signer Transaction internals changed; cannot set locktime');
+        mutableTx.global.fallbackLocktime = locktime;
+    }
+    get locktime() {
+        return __classPrivateFieldGet(this, _ScurePsbtAdapter_tx, "f").lockTime;
+    }
+    signInput(index, signer) {
+        const signed = __classPrivateFieldGet(this, _ScurePsbtAdapter_tx, "f").signIdx(requirePrivateKey(signer), index);
+        if (!signed)
+            throw new Error(`Input ${index} was not signed`);
+    }
+    signAllInputs(signer) {
+        const signedInputs = __classPrivateFieldGet(this, _ScurePsbtAdapter_tx, "f").sign(requirePrivateKey(signer));
+        if (signedInputs === 0)
+            throw new Error('No inputs were signed');
+    }
+    signInputHD(index, hdSigner) {
+        const scureHdSigner = hdSigner;
+        const input = __classPrivateFieldGet(this, _ScurePsbtAdapter_tx, "f").getInput(index);
+        const tapBip32 = input.tapBip32Derivation;
+        if (tapBip32 && tapBip32.length > 0) {
+            const fp = (0, common_1.uint32FromBytesBE)(hdSigner.fingerprint);
+            let matchedFingerprint = false;
+            let signed = false;
+            for (const [, { der }] of tapBip32) {
+                if (der.fingerprint !== fp)
+                    continue;
+                matchedFingerprint = true;
+                let derivedNode = scureHdSigner;
+                for (const childIndex of der.path)
+                    derivedNode = derivedNode.derive(childIndex);
+                signed =
+                    __classPrivateFieldGet(this, _ScurePsbtAdapter_tx, "f").signIdx(requirePrivateKey(derivedNode), index) || signed;
+            }
+            if (!matchedFingerprint)
+                throw new Error('No taproot BIP32 derivation matches signer fingerprint');
+            if (!signed)
+                throw new Error('No inputs were signed');
+        }
+        else {
+            const signed = __classPrivateFieldGet(this, _ScurePsbtAdapter_tx, "f").signIdx(toScureHDKey(scureHdSigner), index);
+            if (!signed)
+                throw new Error('No inputs were signed');
+        }
+    }
+    signAllInputsHD(hdSigner) {
+        let signedInputs = 0;
+        for (let i = 0; i < __classPrivateFieldGet(this, _ScurePsbtAdapter_tx, "f").inputsLength; i++) {
+            try {
+                this.signInputHD(i, hdSigner);
+                signedInputs++;
+            }
+            catch {
+                // Keep parity with bitcoinjs signAllInputs*: skip unsignable inputs.
+            }
+        }
+        if (signedInputs === 0)
+            throw new Error('No inputs were signed');
+    }
+    finalizeInput(index, finalizer) {
+        if (finalizer) {
+            const rawInput = __classPrivateFieldGet(this, _ScurePsbtAdapter_tx, "f").getInput(index);
+            if (!rawInput)
+                throw new Error(`Invalid input index ${index}`);
+            const input = scureInputToBitcoinjs(rawInput);
+            const witnessUtxo = input.witnessUtxo;
+            const redeemScript = input.redeemScript;
+            const witnessScript = input.witnessScript;
+            const script = witnessScript ??
+                redeemScript ??
+                witnessUtxo?.script ??
+                new Uint8Array();
+            const result = finalizer(index, input, script, !!witnessUtxo, !!redeemScript, !!witnessScript);
+            const updateFields = {};
+            if (result.finalScriptSig)
+                updateFields['finalScriptSig'] = result.finalScriptSig;
+            if (result.finalScriptWitness)
+                updateFields['finalScriptWitness'] = script_js_1.RawWitness.decode(result.finalScriptWitness);
+            __classPrivateFieldGet(this, _ScurePsbtAdapter_tx, "f").updateInput(index, updateFields, true);
+            return;
+        }
+        __classPrivateFieldGet(this, _ScurePsbtAdapter_tx, "f").finalizeIdx(index);
+    }
+    finalizeTaprootInput(index, tapLeafHashToFinalize, finalizer) {
+        if (tapLeafHashToFinalize !== undefined)
+            throw new Error('Error: scure adapter does not implement tapLeafHashToFinalize in finalizeTaprootInput');
+        const result = finalizer();
+        __classPrivateFieldGet(this, _ScurePsbtAdapter_tx, "f").updateInput(index, {
+            finalScriptWitness: script_js_1.RawWitness.decode(result.finalScriptWitness)
+        }, true);
+    }
+    validateSignaturesOfInput(index, validator) {
+        void validator;
+        if (!warnedAboutScureSignatureValidation) {
+            console.warn('Warning: @scure/btc-signer adapter does not perform full cryptographic signature validation. Use validate=false to skip validation checks, or use bitcoinjs-lib if full signature validation is required.');
+            warnedAboutScureSignatureValidation = true;
+        }
+        const input = __classPrivateFieldGet(this, _ScurePsbtAdapter_tx, "f").getInput(index);
+        if (!input)
+            throw new Error(`Invalid input index ${index}`);
+        if (input.tapKeySig)
+            return true;
+        if (Array.isArray(input.tapScriptSig) && input.tapScriptSig.length > 0)
+            return true;
+        return !!(input.partialSig && input.partialSig.length > 0);
+    }
+    updateInput(index, data) {
+        __classPrivateFieldGet(this, _ScurePsbtAdapter_tx, "f").updateInput(index, toScureInputUpdate(data));
+    }
+    toBase64() {
+        return base_1.base64.encode(__classPrivateFieldGet(this, _ScurePsbtAdapter_tx, "f").toPSBT());
+    }
+}
+_ScurePsbtAdapter_tx = new WeakMap();
+/** Wrap a raw @scure/btc-signer Transaction into a PsbtLike adapter. */
+function wrapScureTransaction(transaction) {
+    return new ScurePsbtAdapter(transaction);
+}

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

@@ -0,0 +1,20 @@
+/** Convert ASM string to script bytes. */
+export declare function fromASM(asm: string): import("micro-packed").Bytes;
+/** Decompile script to array of opcodes (numbers) and data (Uint8Array). */
+export declare function decompile(script: Uint8Array): (number | Uint8Array<ArrayBufferLike>)[] | null;
+/** Count non-push-only opcodes in a script. */
+export declare function countNonPushOnlyOPs(chunks: Array<number | Uint8Array>): number;
+/** Decompile a script into its push-data items. */
+export declare function toStack(scriptBuf: Uint8Array): Uint8Array<ArrayBufferLike>[];
+/** Encode a number for use in Bitcoin Script (CScriptNum format). */
+declare function numberEncode(n: number): import("micro-packed").Bytes;
+export declare function createScureScriptAdapter(): {
+    fromASM: typeof fromASM;
+    toStack: typeof toStack;
+    decompile: typeof decompile;
+    countNonPushOnlyOPs: typeof countNonPushOnlyOPs;
+    number: {
+        encode: typeof numberEncode;
+    };
+};
+export {};

package/dist/adapters/scure/script.js

@@ -0,0 +1,163 @@
+"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.fromASM = fromASM;
+exports.decompile = decompile;
+exports.countNonPushOnlyOPs = countNonPushOnlyOPs;
+exports.toStack = toStack;
+exports.createScureScriptAdapter = createScureScriptAdapter;
+const btc = __importStar(require("@scure/btc-signer"));
+const base_1 = require("@scure/base");
+const SIGNER_OP_NAMES = new Set();
+for (const key of Object.keys(btc.OP))
+    if (isNaN(Number(key)))
+        SIGNER_OP_NAMES.add(key);
+function isPushOnlyChunk(chunk) {
+    if (chunk instanceof Uint8Array)
+        return true;
+    return (chunk === btc.OP.OP_0 ||
+        chunk === btc.OP['1NEGATE'] ||
+        (chunk >= btc.OP.OP_1 && chunk <= btc.OP.OP_16));
+}
+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. */
+function fromASM(asm) {
+    const trimmed = asm.trim();
+    if (trimmed === '')
+        throw new Error('Invalid ASM string');
+    const tokens = trimmed.split(/\s+/);
+    const scriptElements = [];
+    for (const token of tokens) {
+        if (token === '')
+            continue;
+        const op = asmTokenToSignerOp(token);
+        if (op !== undefined) {
+            scriptElements.push(op);
+        }
+        else {
+            const data = base_1.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);
+        }
+    }
+    return btc.Script.encode(scriptElements);
+}
+/** Decompile script to array of opcodes (numbers) and data (Uint8Array). */
+function decompile(script) {
+    try {
+        const decoded = btc.Script.decode(script);
+        return decoded.map(item => {
+            if (typeof item === 'number') {
+                if (item === 0)
+                    return btc.OP.OP_0;
+                if (item >= 1 && item <= 16)
+                    return btc.OP.RESERVED + item;
+                return item;
+            }
+            if (item instanceof Uint8Array)
+                return item;
+            const opNum = btc.OP[item];
+            if (opNum !== undefined)
+                return opNum;
+            throw new Error('Unknown script token');
+        });
+    }
+    catch {
+        return null;
+    }
+}
+/** Count non-push-only opcodes in a script. */
+function countNonPushOnlyOPs(chunks) {
+    return chunks.length - chunks.filter(isPushOnlyChunk).length;
+}
+/** Decompile a script into its push-data items. */
+function toStack(scriptBuf) {
+    const chunks = decompile(scriptBuf);
+    if (!chunks)
+        throw new Error('Could not decompile script');
+    if (!chunks.every(isPushOnlyChunk))
+        throw new Error('Non push-only script');
+    return chunks.map(chunk => {
+        if (typeof chunk === 'number') {
+            if (chunk === btc.OP.OP_0)
+                return new Uint8Array(0);
+            return numberEncode(chunk - btc.OP.RESERVED);
+        }
+        return chunk;
+    });
+}
+/** Encode a number for use in Bitcoin Script (CScriptNum format). */
+function numberEncode(n) {
+    if (!Number.isSafeInteger(n))
+        throw new Error(`Error: invalid script number ${n}`);
+    return btc.ScriptNum().encode(BigInt(n));
+}
+function createScureScriptAdapter() {
+    return {
+        fromASM,
+        toStack,
+        decompile,
+        countNonPushOnlyOPs,
+        number: {
+            encode: numberEncode
+        }
+    };
+}

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

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

package/dist/adapters/scure/transaction.js

@@ -0,0 +1,32 @@
+"use strict";
+// Copyright (c) 2026 Jose-Luis Landabaso - https://bitcoinerlab.com
+// Distributed under the MIT software license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createScureTransactionAdapter = createScureTransactionAdapter;
+const base_1 = require("@scure/base");
+const script_js_1 = require("@scure/btc-signer/script.js");
+const crypto_1 = require("../../crypto");
+function parseRawTx(rawBytes) {
+    const parsed = script_js_1.RawTx.decode(rawBytes);
+    const nonWitnessSerialization = script_js_1.RawOldTx.encode(parsed);
+    const txidHash = (0, crypto_1.sha256)((0, crypto_1.sha256)(nonWitnessSerialization));
+    const txidBytes = txidHash.slice().reverse();
+    return {
+        getId: () => base_1.hex.encode(txidBytes),
+        outs: parsed.outputs.map(o => ({
+            script: o.script,
+            value: o.amount
+        })),
+        toBuffer: () => rawBytes
+    };
+}
+function createScureTransactionAdapter() {
+    return {
+        fromHex(hexStr) {
+            return parseRawTx(base_1.hex.decode(hexStr));
+        },
+        fromBuffer(buf) {
+            return parseRawTx(buf);
+        }
+    };
+}

package/dist/adapters/scure.d.ts

@@ -0,0 +1,6 @@
+import type { BitcoinLib } from '../bitcoinLib';
+export { wrapScureTransaction } from './scure/psbt';
+/**
+ * Create a BitcoinLib backed by @scure/btc-signer.
+ */
+export declare function createScureLib(): BitcoinLib;

package/dist/adapters/scure.js

@@ -0,0 +1,37 @@
+"use strict";
+// Copyright (c) 2026 Jose-Luis Landabaso - https://bitcoinerlab.com
+// Distributed under the MIT software license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapScureTransaction = void 0;
+exports.createScureLib = createScureLib;
+/**
+ * @scure/btc-signer adapter for BitcoinLib.
+ *
+ * Wraps @scure/btc-signer and related scure/noble packages into the
+ * BitcoinLib interface.
+ */
+const secp256k1_js_1 = require("@noble/curves/secp256k1.js");
+const payments_1 = require("./scure/payments");
+const script_1 = require("./scure/script");
+const transaction_1 = require("./scure/transaction");
+const address_1 = require("./scure/address");
+const ecpair_1 = require("./scure/ecpair");
+const bip32_1 = require("./scure/bip32");
+var psbt_1 = require("./scure/psbt");
+Object.defineProperty(exports, "wrapScureTransaction", { enumerable: true, get: function () { return psbt_1.wrapScureTransaction; } });
+/**
+ * Create a BitcoinLib backed by @scure/btc-signer.
+ */
+function createScureLib() {
+    return {
+        payments: (0, payments_1.createScurePaymentsAdapter)(),
+        script: (0, script_1.createScureScriptAdapter)(),
+        Transaction: (0, transaction_1.createScureTransactionAdapter)(),
+        address: (0, address_1.createScureAddressAdapter)(),
+        ECPair: (0, ecpair_1.createScureECPairAdapter)(),
+        BIP32: (0, bip32_1.createScureBIP32Adapter)(),
+        verifySchnorr(msghash, pubkey, signature) {
+            return secp256k1_js_1.schnorr.verify(signature, msghash, pubkey);
+        }
+    };
+}

package/dist/adapters/scureKeys.d.ts

@@ -0,0 +1,4 @@
+import type { BIP32InterfaceLike, ECPairInterfaceLike, ScureHDKeyLike } from '../bitcoinLib';
+export declare function wrapScurePrivateKey(privateKey: Uint8Array, compressed?: boolean): ECPairInterfaceLike;
+export declare function wrapScurePublicKey(publicKey: Uint8Array): ECPairInterfaceLike;
+export declare function wrapScureHDKey(node: ScureHDKeyLike): BIP32InterfaceLike;