@btc-vision/transaction 1.8.6 → 1.8.7-beta.0

package/build/transaction/mineable/CSVMultisigProvider.d.ts

@@ -0,0 +1,102 @@
+import { type Network, type Psbt, type Script, type TapScriptSig, type XOnlyPublicKey } from '@btc-vision/bitcoin';
+import type { UTXO } from '../../utxo/interfaces/IUTXO.js';
+export declare const NUMS_INTERNAL_KEY: Uint8Array;
+export declare const LEAF_VERSION_TAPSCRIPT = 192;
+export interface CSVMultisigConfig {
+    /** x,only (32 byte) pubkeys. Signature order is the reverse of this array. */
+    pubkeys: XOnlyPublicKey[];
+    /** k of n threshold, fixed at 2 for CSV2Multisig but kept configurable. */
+    threshold: number;
+    /** Block,based relative lock, 1..65535. */
+    csvBlocks: number;
+}
+export interface CSVMultisigAddress {
+    address: string;
+    tapscript: Uint8Array;
+    scriptPubKey: Uint8Array;
+    controlBlock: Uint8Array;
+    internalPubkey: Uint8Array;
+    leafVersion: number;
+    config: CSVMultisigConfig;
+}
+export declare class CSVMultisigProvider {
+    static readonly NUMS_INTERNAL_KEY: Uint8Array<ArrayBufferLike>;
+    static readonly LEAF_VERSION = 192;
+    /** Build the CSV + k of n CHECKSIGADD tapscript. */
+    static buildTapscript(cfg: CSVMultisigConfig): Script;
+    /** Convenience: 2 of N with fixed threshold. */
+    static buildCSV2MultisigTapscript(pubkeys: XOnlyPublicKey[], csvBlocks: number): Uint8Array;
+    /** Single leaf tree, NUMS internal key, key path is unspendable. */
+    static generateAddress(cfg: CSVMultisigConfig, network: Network): CSVMultisigAddress;
+    /**
+     * Encode the nSequence value the spending input must use.
+     * BIP 68: disable bit (1 << 31) = 0, type,flag (1 << 22) = 0 for blocks,
+     * low 16 bits carry the block count.
+     */
+    static encodeSequence(csvBlocks: number): number;
+    /**
+     * Build witness stack for a script path spend.
+     *
+     * Returns { witness, sequence }. The caller MUST set nSequence = sequence
+     * on the spending input, otherwise OP_CHECKSEQUENCEVERIFY will fail.
+     * Transaction nVersion must be >= 2 for CSV to be enforced at all.
+     */
+    static buildSpendWitness(signatures: Uint8Array[], addr: CSVMultisigAddress): {
+        witness: Uint8Array[];
+        sequence: number;
+    };
+    static isP2TRScriptPubKey(scriptPubKey: Uint8Array): boolean;
+    /**
+     * Derive the full CSV multisig address from just the tapscript.
+     *
+     * The tapscript alone fully determines the address because:
+     *  - the internal key is the hard coded NUMS point,
+     *  - the tap tree is a single leaf,
+     *  - the leaf version is LEAF_VERSION_TAPSCRIPT (0xc0).
+     *
+     * Returns null when the tapscript does not match the CSV multisig shape.
+     */
+    static deriveAddressFromTapscript(tapscript: Uint8Array, network: Network): CSVMultisigAddress | null;
+    /**
+     * Witness stack size needed for fee estimation.
+     *
+     * threshold 64-byte Schnorr sigs at the bottom (pushed first by the caller),
+     * plus (n - threshold) empty placeholders for unsigned slots,
+     * plus the tapscript, plus the control block.
+     */
+    static buildDummyWitness(addr: CSVMultisigAddress): Uint8Array[];
+    /**
+     * Build the final witness stack from collected PSBT tapScriptSig entries.
+     *
+     * Each entry is matched to its pubkey in the tapscript. Missing entries
+     * produce empty (zero-length) placeholders so the remaining signatures can
+     * still validate at positions above threshold.
+     */
+    static buildFinalWitnessFromTapScriptSigs(tapScriptSigs: readonly TapScriptSig[], addr: CSVMultisigAddress): Uint8Array[];
+    /**
+     * True when this UTXO is a CSV multisig P2TR output that this provider can spend.
+     *
+     * Requires both the P2TR scriptPubKey and a witnessScript (the tapscript) on
+     * the UTXO, and checks the tapscript shape AND that the scriptPubKey matches
+     * the address derived from that tapscript (prevents spoofed witnessScripts).
+     */
+    static isSpendableUTXO(utxo: UTXO, network: Network): boolean;
+    /**
+     * Parse a tapscript that matches the CSV + CHECKSIGADD multisig shape.
+     * Returns null if the script does not match.
+     */
+    static parseTapscript(tapscript: Uint8Array): CSVMultisigConfig | null;
+    /**
+     * Finalize a single PSBT input that was set up as a CSV multisig P2TR spend.
+     *
+     * Collects the tapScriptSig entries that cosigners have added to the PSBT
+     * input and writes the final witness. Designed for the collaborative case
+     * where signers accumulate signatures on a shared PSBT and then anyone
+     * finalizes once threshold is met.
+     *
+     * `addr` may be omitted when the input's first tapLeafScript carries the
+     * tapscript — it is then re-derived here.
+     */
+    static finalizePsbtInput(psbt: Psbt, inputIndex: number, network: Network, addr?: CSVMultisigAddress): void;
+    static isCSVMultisigUTXO(utxo: UTXO): boolean;
+}

package/build/transaction/mineable/CSVMultisigProvider.js

@@ -0,0 +1,348 @@
+import { equals, fromHex, isP2TR, opcodes, payments, script, } from '@btc-vision/bitcoin';
+import { witnessStackToScriptWitness } from '../utils/WitnessUtils.js';
+export const NUMS_INTERNAL_KEY = fromHex('50929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0');
+export const LEAF_VERSION_TAPSCRIPT = 0xc0;
+export class CSVMultisigProvider {
+    static NUMS_INTERNAL_KEY = NUMS_INTERNAL_KEY;
+    static LEAF_VERSION = LEAF_VERSION_TAPSCRIPT;
+    /** Build the CSV + k of n CHECKSIGADD tapscript. */
+    static buildTapscript(cfg) {
+        if (cfg.csvBlocks < 1 || cfg.csvBlocks > 0xffff) {
+            throw new Error('csvBlocks must be between 1 and 65535');
+        }
+        if (cfg.pubkeys.length === 0) {
+            throw new Error('At least one pubkey required');
+        }
+        if (cfg.threshold < 1 || cfg.threshold > cfg.pubkeys.length) {
+            throw new Error('Invalid threshold');
+        }
+        for (const pk of cfg.pubkeys) {
+            if (pk.length !== 32) {
+                throw new Error('Tapscript pubkeys must be 32 bytes (x,only)');
+            }
+        }
+        const chunks = [];
+        // Relative timelock gate
+        chunks.push(script.number.encode(cfg.csvBlocks));
+        chunks.push(opcodes.OP_CHECKSEQUENCEVERIFY);
+        chunks.push(opcodes.OP_DROP);
+        // k of n multisig
+        chunks.push(cfg.pubkeys[0], opcodes.OP_CHECKSIG);
+        for (let i = 1; i < cfg.pubkeys.length; i++) {
+            chunks.push(cfg.pubkeys[i], opcodes.OP_CHECKSIGADD);
+        }
+        if (cfg.threshold >= 1 && cfg.threshold <= 16) {
+            chunks.push(opcodes.OP_1 + cfg.threshold - 1);
+        }
+        else {
+            chunks.push(script.number.encode(cfg.threshold));
+        }
+        chunks.push(opcodes.OP_NUMEQUAL);
+        return script.compile(chunks);
+    }
+    /** Convenience: 2 of N with fixed threshold. */
+    static buildCSV2MultisigTapscript(pubkeys, csvBlocks) {
+        return this.buildTapscript({ pubkeys, threshold: 2, csvBlocks });
+    }
+    /** Single leaf tree, NUMS internal key, key path is unspendable. */
+    static generateAddress(cfg, network) {
+        const tapscript = this.buildTapscript(cfg);
+        const p2tr = payments.p2tr({
+            internalPubkey: NUMS_INTERNAL_KEY,
+            scriptTree: { output: tapscript },
+            redeem: {
+                output: tapscript,
+                redeemVersion: LEAF_VERSION_TAPSCRIPT,
+            },
+            network,
+        });
+        if (!p2tr.address || !p2tr.output || !p2tr.witness || p2tr.witness.length < 2) {
+            throw new Error('Failed to generate CSV multisig P2TR address');
+        }
+        const control = p2tr.witness[p2tr.witness.length - 1];
+        if (!control) {
+            throw new Error('Failed to generate CSV multisig P2TR address');
+        }
+        return {
+            address: p2tr.address,
+            tapscript,
+            scriptPubKey: p2tr.output,
+            controlBlock: control,
+            internalPubkey: NUMS_INTERNAL_KEY,
+            leafVersion: LEAF_VERSION_TAPSCRIPT,
+            config: cfg,
+        };
+    }
+    /**
+     * Encode the nSequence value the spending input must use.
+     * BIP 68: disable bit (1 << 31) = 0, type,flag (1 << 22) = 0 for blocks,
+     * low 16 bits carry the block count.
+     */
+    static encodeSequence(csvBlocks) {
+        if (csvBlocks < 1 || csvBlocks > 0xffff) {
+            throw new Error('csvBlocks out of range');
+        }
+        return csvBlocks & 0x0000ffff;
+    }
+    /**
+     * Build witness stack for a script path spend.
+     *
+     * Returns { witness, sequence }. The caller MUST set nSequence = sequence
+     * on the spending input, otherwise OP_CHECKSEQUENCEVERIFY will fail.
+     * Transaction nVersion must be >= 2 for CSV to be enforced at all.
+     */
+    static buildSpendWitness(signatures, addr) {
+        const { config, tapscript, controlBlock } = addr;
+        if (signatures.length !== config.pubkeys.length) {
+            throw new Error('signatures length must match pubkeys length');
+        }
+        for (const sig of signatures) {
+            if (sig.length !== 0 && sig.length !== 64 && sig.length !== 65) {
+                throw new Error('Each sig must be empty, 64, or 65 bytes');
+            }
+        }
+        const provided = signatures.filter((s) => s.length > 0).length;
+        if (provided < config.threshold) {
+            throw new Error(`Need ${config.threshold} signatures, got ${provided}`);
+        }
+        const witness = [];
+        // Reverse pubkey order: sig for pubkeys[0] must end up on top of stack.
+        for (let i = signatures.length - 1; i >= 0; i--) {
+            witness.push(signatures[i]);
+        }
+        witness.push(tapscript);
+        witness.push(controlBlock);
+        return { witness, sequence: this.encodeSequence(config.csvBlocks) };
+    }
+    static isP2TRScriptPubKey(scriptPubKey) {
+        return isP2TR(scriptPubKey);
+    }
+    /**
+     * Derive the full CSV multisig address from just the tapscript.
+     *
+     * The tapscript alone fully determines the address because:
+     *  - the internal key is the hard coded NUMS point,
+     *  - the tap tree is a single leaf,
+     *  - the leaf version is LEAF_VERSION_TAPSCRIPT (0xc0).
+     *
+     * Returns null when the tapscript does not match the CSV multisig shape.
+     */
+    static deriveAddressFromTapscript(tapscript, network) {
+        const config = this.parseTapscript(tapscript);
+        if (!config)
+            return null;
+        return this.generateAddress(config, network);
+    }
+    /**
+     * Witness stack size needed for fee estimation.
+     *
+     * threshold 64-byte Schnorr sigs at the bottom (pushed first by the caller),
+     * plus (n - threshold) empty placeholders for unsigned slots,
+     * plus the tapscript, plus the control block.
+     */
+    static buildDummyWitness(addr) {
+        const { config, tapscript, controlBlock } = addr;
+        const witness = [];
+        // Position 0..n-1 maps to pubkey n-1..0 on the stack.
+        // For estimation we put real 64-byte sigs in the last `threshold` positions
+        // (matching the highest-indexed pubkeys), and empties elsewhere.
+        for (let i = 0; i < config.pubkeys.length; i++) {
+            const stackPos = config.pubkeys.length - 1 - i;
+            if (stackPos < config.threshold) {
+                witness.push(new Uint8Array(64));
+            }
+            else {
+                witness.push(new Uint8Array(0));
+            }
+        }
+        witness.push(tapscript);
+        witness.push(controlBlock);
+        return witness;
+    }
+    /**
+     * Build the final witness stack from collected PSBT tapScriptSig entries.
+     *
+     * Each entry is matched to its pubkey in the tapscript. Missing entries
+     * produce empty (zero-length) placeholders so the remaining signatures can
+     * still validate at positions above threshold.
+     */
+    static buildFinalWitnessFromTapScriptSigs(tapScriptSigs, addr) {
+        const { config, tapscript, controlBlock } = addr;
+        const sigsByPubkey = new Map();
+        for (const entry of tapScriptSigs) {
+            if (!entry.pubkey || entry.pubkey.length !== 32)
+                continue;
+            sigsByPubkey.set(toHexKey(entry.pubkey), entry.signature);
+        }
+        const ordered = [];
+        let provided = 0;
+        for (const pk of config.pubkeys) {
+            const sig = sigsByPubkey.get(toHexKey(pk));
+            if (sig) {
+                if (sig.length !== 64 && sig.length !== 65) {
+                    throw new Error(`Invalid Schnorr signature length ${sig.length} for CSV multisig spend`);
+                }
+                ordered.push(sig);
+                provided++;
+            }
+            else {
+                ordered.push(new Uint8Array(0));
+            }
+        }
+        if (provided < config.threshold) {
+            throw new Error(`CSV multisig spend needs ${config.threshold} signatures, got ${provided}`);
+        }
+        const witness = [];
+        // Reverse pubkey order so that the signature for pubkeys[0] lands on top of the stack.
+        for (let i = ordered.length - 1; i >= 0; i--) {
+            witness.push(ordered[i]);
+        }
+        witness.push(tapscript);
+        witness.push(controlBlock);
+        return witness;
+    }
+    /**
+     * True when this UTXO is a CSV multisig P2TR output that this provider can spend.
+     *
+     * Requires both the P2TR scriptPubKey and a witnessScript (the tapscript) on
+     * the UTXO, and checks the tapscript shape AND that the scriptPubKey matches
+     * the address derived from that tapscript (prevents spoofed witnessScripts).
+     */
+    static isSpendableUTXO(utxo, network) {
+        if (!utxo.witnessScript)
+            return false;
+        const scriptPub = fromHex(utxo.scriptPubKey.hex);
+        if (!isP2TR(scriptPub))
+            return false;
+        const tapscript = utxo.witnessScript instanceof Uint8Array
+            ? utxo.witnessScript
+            : fromHex(utxo.witnessScript);
+        const addr = this.deriveAddressFromTapscript(tapscript, network);
+        if (!addr)
+            return false;
+        return equals(addr.scriptPubKey, scriptPub);
+    }
+    /**
+     * Parse a tapscript that matches the CSV + CHECKSIGADD multisig shape.
+     * Returns null if the script does not match.
+     */
+    static parseTapscript(tapscript) {
+        const d = script.decompile(tapscript);
+        if (!d || d.length < 6)
+            return null;
+        // <csvBlocks> CSV DROP
+        // Small values (1..16) are minimally encoded as OP_N opcodes by
+        // script.compile, so the chunk may be a number rather than a Uint8Array.
+        const csvChunk = d[0];
+        let csvBlocks;
+        if (csvChunk instanceof Uint8Array) {
+            try {
+                csvBlocks = script.number.decode(csvChunk);
+            }
+            catch {
+                return null;
+            }
+        }
+        else if (typeof csvChunk === 'number' &&
+            csvChunk >= opcodes.OP_1 &&
+            csvChunk <= opcodes.OP_16) {
+            csvBlocks = csvChunk - opcodes.OP_1 + 1;
+        }
+        else {
+            return null;
+        }
+        if (d[1] !== opcodes.OP_CHECKSEQUENCEVERIFY)
+            return null;
+        if (d[2] !== opcodes.OP_DROP)
+            return null;
+        // <pk1> CHECKSIG
+        let i = 3;
+        if (!(d[i] instanceof Uint8Array) ||
+            d[i].length !== 32 ||
+            d[i + 1] !== opcodes.OP_CHECKSIG) {
+            return null;
+        }
+        const pubkeys = [d[i]];
+        i += 2;
+        // <pkN> CHECKSIGADD pairs
+        while (i + 1 < d.length &&
+            d[i] instanceof Uint8Array &&
+            d[i].length === 32 &&
+            d[i + 1] === opcodes.OP_CHECKSIGADD) {
+            pubkeys.push(d[i]);
+            i += 2;
+        }
+        // threshold + OP_NUMEQUAL at the end
+        if (i + 2 !== d.length)
+            return null;
+        const threshChunk = d[i];
+        let threshold;
+        if (typeof threshChunk === 'number' &&
+            threshChunk >= opcodes.OP_1 &&
+            threshChunk <= opcodes.OP_16) {
+            threshold = threshChunk - opcodes.OP_1 + 1;
+        }
+        else if (threshChunk instanceof Uint8Array) {
+            threshold = script.number.decode(threshChunk);
+        }
+        else {
+            return null;
+        }
+        if (d[i + 1] !== opcodes.OP_NUMEQUAL)
+            return null;
+        if (threshold < 1 || threshold > pubkeys.length)
+            return null;
+        return { pubkeys, threshold, csvBlocks };
+    }
+    /**
+     * Finalize a single PSBT input that was set up as a CSV multisig P2TR spend.
+     *
+     * Collects the tapScriptSig entries that cosigners have added to the PSBT
+     * input and writes the final witness. Designed for the collaborative case
+     * where signers accumulate signatures on a shared PSBT and then anyone
+     * finalizes once threshold is met.
+     *
+     * `addr` may be omitted when the input's first tapLeafScript carries the
+     * tapscript — it is then re-derived here.
+     */
+    static finalizePsbtInput(psbt, inputIndex, network, addr) {
+        const input = psbt.data.inputs[inputIndex];
+        if (!input) {
+            throw new Error(`PSBT has no input at index ${inputIndex}`);
+        }
+        let descriptor = addr;
+        if (!descriptor) {
+            const tls = input.tapLeafScript;
+            if (!tls || tls.length === 0 || !tls[0]) {
+                throw new Error(`Input #${inputIndex} has no tapLeafScript — pass \`addr\` explicitly`);
+            }
+            const derived = this.deriveAddressFromTapscript(tls[0].script, network);
+            if (!derived) {
+                throw new Error(`Input #${inputIndex} tapLeafScript is not a CSV multisig`);
+            }
+            descriptor = derived;
+        }
+        const tapSigs = input.tapScriptSig ?? [];
+        const witness = this.buildFinalWitnessFromTapScriptSigs(tapSigs, descriptor);
+        psbt.finalizeInput(inputIndex, () => ({
+            finalScriptSig: undefined,
+            finalScriptWitness: witnessStackToScriptWitness(witness),
+        }));
+    }
+    static isCSVMultisigUTXO(utxo) {
+        if (!utxo.witnessScript) {
+            return false;
+        }
+        const tapscript = utxo.witnessScript instanceof Uint8Array
+            ? utxo.witnessScript
+            : fromHex(utxo.witnessScript);
+        return this.parseTapscript(tapscript) !== null;
+    }
+}
+function toHexKey(u8) {
+    let s = '';
+    for (let i = 0; i < u8.length; i++) {
+        s += u8[i].toString(16).padStart(2, '0');
+    }
+    return s;
+}

package/build/transaction/mineable/IP2WSHAddress.d.ts

@@ -2,4 +2,3 @@ export interface IP2WSHAddress {
     address: string;
     witnessScript: Uint8Array;
 }
-//# sourceMappingURL=IP2WSHAddress.d.ts.map

package/build/transaction/mineable/IP2WSHAddress.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=IP2WSHAddress.js.map

package/build/transaction/mineable/TimelockGenerator.d.ts

@@ -20,4 +20,3 @@ export declare class TimeLockGenerator {
     static generateTimeLockAddressP2MR(publicKey: XOnlyPublicKey, network?: Network, csvBlocks?: number): string;
     private static generateTimeLockScript;
 }
-//# sourceMappingURL=TimelockGenerator.d.ts.map

package/build/transaction/mineable/TimelockGenerator.js

@@ -65,4 +65,3 @@ export class TimeLockGenerator {
         ]);
     }
 }
-//# sourceMappingURL=TimelockGenerator.js.map

package/build/transaction/offline/OfflineTransactionManager.d.ts

@@ -247,4 +247,3 @@ export declare class OfflineTransactionManager {
      */
     static multiSigUpdatePsbt(serializedState: string, psbtBase64: string): string;
 }
-//# sourceMappingURL=OfflineTransactionManager.d.ts.map

package/build/transaction/offline/OfflineTransactionManager.js

@@ -436,4 +436,3 @@ export class OfflineTransactionManager {
         return TransactionSerializer.toBase64(newState);
     }
 }
-//# sourceMappingURL=OfflineTransactionManager.js.map

package/build/transaction/offline/TransactionReconstructor.d.ts

@@ -75,4 +75,3 @@ export declare class TransactionReconstructor {
      */
     private static nameToNetwork;
 }
-//# sourceMappingURL=TransactionReconstructor.d.ts.map

package/build/transaction/offline/TransactionReconstructor.js

@@ -314,4 +314,3 @@ export class TransactionReconstructor {
         }
     }
 }
-//# sourceMappingURL=TransactionReconstructor.js.map

package/build/transaction/offline/TransactionSerializer.d.ts

@@ -98,4 +98,3 @@ export declare class TransactionSerializer {
     private static networkNameToU8;
     private static u8ToNetworkName;
 }
-//# sourceMappingURL=TransactionSerializer.d.ts.map

package/build/transaction/offline/TransactionSerializer.js

@@ -797,4 +797,3 @@ export class TransactionSerializer {
         }
     }
 }
-//# sourceMappingURL=TransactionSerializer.js.map

package/build/transaction/offline/TransactionStateCapture.d.ts

@@ -108,4 +108,3 @@ export declare class TransactionStateCapture {
      */
     private static networkToChainId;
 }
-//# sourceMappingURL=TransactionStateCapture.d.ts.map

package/build/transaction/offline/TransactionStateCapture.js

@@ -366,4 +366,3 @@ export class TransactionStateCapture {
         return ChainId.Bitcoin;
     }
 }
-//# sourceMappingURL=TransactionStateCapture.js.map

package/build/transaction/offline/interfaces/ISerializableState.d.ts

@@ -130,4 +130,3 @@ export interface ISerializableTransactionState {
     /** Pre-computed data for deterministic rebuild */
     readonly precomputedData: PrecomputedData;
 }
-//# sourceMappingURL=ISerializableState.d.ts.map

package/build/transaction/offline/interfaces/ISerializableState.js

@@ -8,4 +8,3 @@ export const SERIALIZATION_FORMAT_VERSION = 1;
  * Magic byte for identifying serialized transaction state
  */
 export const SERIALIZATION_MAGIC_BYTE = 0x42; // 'B' for Bitcoin
-//# sourceMappingURL=ISerializableState.js.map

package/build/transaction/offline/interfaces/ITypeSpecificData.d.ts

@@ -135,4 +135,3 @@ export declare function isCustomScriptSpecificData(data: TypeSpecificData): data
  * Type guard for CancelSpecificData
  */
 export declare function isCancelSpecificData(data: TypeSpecificData): data is CancelSpecificData;
-//# sourceMappingURL=ITypeSpecificData.d.ts.map

package/build/transaction/offline/interfaces/ITypeSpecificData.js

@@ -35,4 +35,3 @@ export function isCustomScriptSpecificData(data) {
 export function isCancelSpecificData(data) {
     return data.type === TransactionType.CANCEL;
 }
-//# sourceMappingURL=ITypeSpecificData.js.map

package/build/transaction/psbt/PSBTTypes.d.ts

@@ -1,4 +1,3 @@
 export declare enum PSBTTypes {
     UNWRAP = 0
 }
-//# sourceMappingURL=PSBTTypes.d.ts.map

package/build/transaction/psbt/PSBTTypes.js

@@ -2,4 +2,3 @@ export var PSBTTypes;
 (function (PSBTTypes) {
     PSBTTypes[PSBTTypes["UNWRAP"] = 0] = "UNWRAP";
 })(PSBTTypes || (PSBTTypes = {}));
-//# sourceMappingURL=PSBTTypes.js.map

package/build/transaction/shared/P2MR_MS.d.ts

@@ -10,4 +10,3 @@ export declare class P2MR_MS {
      */
     static generateMultiSigAddress(pubKeys: Uint8Array[], minimumSignatureRequired: number, network?: Network): string;
 }
-//# sourceMappingURL=P2MR_MS.d.ts.map

package/build/transaction/shared/P2MR_MS.js

@@ -34,4 +34,3 @@ export class P2MR_MS {
         return address;
     }
 }
-//# sourceMappingURL=P2MR_MS.js.map

package/build/transaction/shared/P2TR_MS.d.ts

@@ -10,4 +10,3 @@ export declare class P2TR_MS {
      */
     static generateMultiSigAddress(pubKeys: Uint8Array[], minimumSignatureRequired: number, network?: Network): string;
 }
-//# sourceMappingURL=P2TR_MS.d.ts.map

package/build/transaction/shared/P2TR_MS.js

@@ -33,4 +33,3 @@ export class P2TR_MS {
         return address;
     }
 }
-//# sourceMappingURL=P2TR_MS.js.map

package/build/transaction/shared/TweakedTransaction.d.ts

@@ -5,6 +5,7 @@ import { type UniversalSigner } from '@btc-vision/ecpair';
 import type { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import type { TapLeafScript } from '../interfaces/Tap.js';
 import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
+import { type CSVMultisigAddress } from '../mineable/CSVMultisigProvider.js';
 import type { QuantumBIP32Interface } from '@btc-vision/bip32';
 import { type RotationSigner, type SignerMap } from '../../signer/AddressRotation.js';
 import type { ITweakedTransactionData, SupportedTransactionVersion } from '../interfaces/ITweakedTransactionData.js';
@@ -93,6 +94,12 @@ export declare abstract class TweakedTransaction extends Logger implements Dispo
      */
     protected csvInputIndices: Set<number>;
     protected anchorInputIndices: Set<number>;
+    /**
+     * Track P2TR CSV multisig inputs together with the address descriptor needed
+     * to finalize them (tapscript + derived control block + parsed config).
+     * @protected
+     */
+    protected csvMultisigInputs: Map<number, CSVMultisigAddress>;
     protected regenerated: boolean;
     protected ignoreSignatureErrors: boolean;
     protected noSignatures: boolean;
@@ -331,6 +338,18 @@ export declare abstract class TweakedTransaction extends Logger implements Dispo
      * @returns {PsbtInputExtended} The PSBT input extended
      */
     protected generatePsbtInputExtended(utxo: UTXO, i: number, _extra?: boolean): PsbtInputExtended;
+    /**
+     * Detect + configure a P2TR CSV multisig input for script-path spending.
+     *
+     * UTXOs of this shape carry the tapscript in `witnessScript`. The control
+     * block and internal pubkey are fully determined by the tapscript (single
+     * leaf tree, NUMS internal key) so the caller only needs to provide the
+     * tapscript.
+     *
+     * Returns true when the UTXO was recognized and the input was configured,
+     * false otherwise (caller falls back to the default P2TR key-path setup).
+     */
+    protected processCSVMultisigP2TRInput(utxo: UTXO, input: PsbtInputExtended, i: number, scriptPub: Uint8Array): boolean;
     protected processP2WSHInput(utxo: UTXO, input: PsbtInputExtended, i: number): void;
     protected secondsToCSVTimeUnits(seconds: number): number;
     protected createTimeBasedCSV(seconds: number): number;
@@ -357,4 +376,3 @@ export declare abstract class TweakedTransaction extends Logger implements Dispo
     private signTaprootInput;
     private signNonTaprootInput;
 }
-//# sourceMappingURL=TweakedTransaction.d.ts.map