@btc-vision/transaction 1.6.1 → 1.6.5

package/src/transaction/shared/TweakedTransaction.ts

@@ -3,6 +3,7 @@ import {
     address as bitAddress,
     crypto as bitCrypto,
     getFinalScripts,
+    isP2A,
     isP2MS,
     isP2PK,
     isP2PKH,
@@ -14,7 +15,6 @@ import {
     Network,
     opcodes,
     P2TRPayment,
-    Payment,
     payments,
     PaymentType,
     Psbt,
@@ -38,6 +38,11 @@ import {
     isTaprootInput,
     pubkeyInScript,
 } from '../../signer/SignerUtils.js';
+import { TransactionBuilder } from '../builders/TransactionBuilder.js';
+import { Buffer } from 'buffer';
+import { P2WDADetector } from '../../p2wda/P2WDADetector.js';
+
+export type SupportedTransactionVersion = 1 | 2 | 3;
 
 export interface ITweakedTransactionData {
     readonly signer: Signer | ECPairInterface | UnisatSigner;
@@ -46,6 +51,7 @@ export interface ITweakedTransactionData {
     readonly nonWitnessUtxo?: Buffer;
     readonly noSignatures?: boolean;
     readonly unlockScript?: Buffer[];
+    readonly txVersion?: SupportedTransactionVersion;
 }
 
 /**
@@ -56,6 +62,13 @@ export enum TransactionSequence {
     FINAL = 0xffffffff,
 }
 
+export enum CSVModes {
+    BLOCKS = 0,
+    TIMESTAMPS = 1,
+}
+
+const CSV_ENABLED_BLOCKS_MASK = 0x3fffffff;
+
 /**
  * @description PSBT Transaction processor.
  * */
@@ -88,33 +101,40 @@ export abstract class TweakedTransaction extends Logger {
      * @protected
      */
     protected abstract readonly transaction: Psbt;
+
     /**
      * @description The sighash types of the transaction
      * @protected
      */
     protected sighashTypes: number[] | undefined;
+
     /**
      * @description The script data of the transaction
      */
     protected scriptData: P2TRPayment | null = null;
+
     /**
      * @description The tap data of the transaction
      */
     protected tapData: P2TRPayment | null = null;
+
     /**
      * @description The inputs of the transaction
      */
     protected readonly inputs: PsbtInputExtended[] = [];
+
     /**
      * @description The sequence of the transaction
      * @protected
      */
     protected sequence: number = TransactionSequence.REPLACE_BY_FEE;
+
     /**
      * The tap leaf script
      * @protected
      */
     protected tapLeafScript: TapLeafScript | null = null;
+
     /**
      * Add a non-witness utxo to the transaction
      * @protected
@@ -127,11 +147,20 @@ export abstract class TweakedTransaction extends Logger {
      */
     protected readonly isBrowser: boolean = false;
 
+    /**
+     * Track which inputs contain CSV scripts
+     * @protected
+     */
+    protected csvInputIndices: Set<number> = new Set();
+    protected anchorInputIndices: Set<number> = new Set();
+
     protected regenerated: boolean = false;
     protected ignoreSignatureErrors: boolean = false;
     protected noSignatures: boolean = false;
     protected unlockScript: Buffer[] | undefined;
 
+    protected txVersion: SupportedTransactionVersion = 2;
+
     protected constructor(data: ITweakedTransactionData) {
         super();
 
@@ -143,6 +172,10 @@ export abstract class TweakedTransaction extends Logger {
         this.unlockScript = data.unlockScript;
 
         this.isBrowser = typeof window !== 'undefined';
+
+        if (data.txVersion) {
+            this.txVersion = data.txVersion;
+        }
     }
 
     /**
@@ -303,6 +336,11 @@ export abstract class TweakedTransaction extends Logger {
         this.sequence = TransactionSequence.FINAL;
 
         for (const input of this.inputs) {
+            // This would disable CSV! You need to check if the input has CSV
+            if (this.csvInputIndices.has(this.inputs.indexOf(input))) {
+                continue;
+            }
+
             input.sequence = TransactionSequence.FINAL;
         }
     }
@@ -402,6 +440,8 @@ export abstract class TweakedTransaction extends Logger {
         reverse: boolean = false,
         errored: boolean = false,
     ): Promise<void> {
+        if (this.anchorInputIndices.has(i)) return;
+
         const publicKey = signer.publicKey;
 
         let isTaproot = isTaprootInput(input);
@@ -672,7 +712,7 @@ export abstract class TweakedTransaction extends Logger {
         i: number,
         _extra: boolean = false,
     ): PsbtInputExtended {
-        const script = Buffer.from(utxo.scriptPubKey.hex, 'hex');
+        const scriptPub = Buffer.from(utxo.scriptPubKey.hex, 'hex');
 
         const input: PsbtInputExtended = {
             hash: utxo.transactionId,
@@ -680,12 +720,12 @@ export abstract class TweakedTransaction extends Logger {
             sequence: this.sequence,
             witnessUtxo: {
                 value: Number(utxo.value),
-                script,
+                script: scriptPub,
             },
         };
 
         // Handle P2PKH (Legacy)
-        if (isP2PKH(script)) {
+        if (isP2PKH(scriptPub)) {
             // Legacy input requires nonWitnessUtxo
             if (utxo.nonWitnessUtxo) {
                 //delete input.witnessUtxo;
@@ -698,28 +738,18 @@ export abstract class TweakedTransaction extends Logger {
         }
 
         // Handle P2WPKH (SegWit)
-        else if (isP2WPKH(script) || isUnknownSegwitVersion(script)) {
+        else if (isP2WPKH(scriptPub) || isUnknownSegwitVersion(scriptPub)) {
             // No redeemScript required for pure P2WPKH
             // witnessUtxo is enough, no nonWitnessUtxo needed.
         }
 
         // Handle P2WSH (SegWit)
-        else if (isP2WSHScript(script)) {
-            // P2WSH requires a witnessScript
-            if (!utxo.witnessScript) {
-                // Can't just invent a witnessScript out of thin air. If not provided, it's an error.
-                throw new Error('Missing witnessScript for P2WSH UTXO');
-            }
-
-            input.witnessScript = Buffer.isBuffer(utxo.witnessScript)
-                ? utxo.witnessScript
-                : Buffer.from(utxo.witnessScript, 'hex');
-
-            // No nonWitnessUtxo needed for segwit
+        else if (isP2WSHScript(scriptPub)) {
+            this.processP2WSHInput(utxo, input, i);
         }
 
         // Handle P2SH (Can be legacy or wrapping segwit)
-        else if (isP2SHScript(script)) {
+        else if (isP2SHScript(scriptPub)) {
             // Redeem script is required for P2SH
             let redeemScriptBuf: Buffer | undefined;
 
@@ -771,9 +801,8 @@ export abstract class TweakedTransaction extends Logger {
                 // P2SH-P2WSH
                 // Use witnessUtxo + redeemScript + witnessScript
                 delete input.nonWitnessUtxo; // ensure we do NOT have nonWitnessUtxo
-                if (!input.witnessScript) {
-                    throw new Error('Missing witnessScript for P2SH-P2WSH UTXO');
-                }
+
+                this.processP2WSHInput(utxo, input, i);
             } else {
                 // Legacy P2SH
                 // Use nonWitnessUtxo
@@ -782,7 +811,7 @@ export abstract class TweakedTransaction extends Logger {
         }
 
         // Handle P2TR (Taproot)
-        else if (isP2TR(script)) {
+        else if (isP2TR(scriptPub)) {
             // Taproot inputs do not require nonWitnessUtxo, witnessUtxo is sufficient.
 
             // If there's a configured sighash type
@@ -796,8 +825,15 @@ export abstract class TweakedTransaction extends Logger {
             input.tapInternalKey = this.internalPubKeyToXOnly();
         }
 
+        // Handle P2A (Any SegWit version, future versions)
+        else if (isP2A(scriptPub)) {
+            this.anchorInputIndices.add(i);
+
+            input.isPayToAnchor = true;
+        }
+
         // Handle P2PK (legacy) or P2MS (bare multisig)
-        else if (isP2PK(script) || isP2MS(script)) {
+        else if (isP2PK(scriptPub) || isP2MS(scriptPub)) {
             // These are legacy scripts, need nonWitnessUtxo
             if (utxo.nonWitnessUtxo) {
                 input.nonWitnessUtxo = Buffer.isBuffer(utxo.nonWitnessUtxo)
@@ -836,6 +872,56 @@ export abstract class TweakedTransaction extends Logger {
         return input;
     }
 
+    protected processP2WSHInput(utxo: UTXO, input: PsbtInputExtended, i: number): void {
+        // P2WSH requires a witnessScript
+        if (!utxo.witnessScript) {
+            // Can't just invent a witnessScript out of thin air. If not provided, it's an error.
+            throw new Error('Missing witnessScript for P2WSH UTXO');
+        }
+
+        input.witnessScript = Buffer.isBuffer(utxo.witnessScript)
+            ? utxo.witnessScript
+            : Buffer.from(utxo.witnessScript, 'hex');
+
+        // No nonWitnessUtxo needed for segwit
+
+        const decompiled = script.decompile(input.witnessScript);
+        if (decompiled && this.isCSVScript(decompiled)) {
+            const decompiled = script.decompile(input.witnessScript);
+            if (decompiled && this.isCSVScript(decompiled)) {
+                this.csvInputIndices.add(i);
+
+                // Extract CSV value from witness script
+                const csvBlocks = this.extractCSVBlocks(decompiled);
+
+                console.log('csvBlocks', csvBlocks);
+
+                // Use the setCSVSequence method to properly set the sequence
+                input.sequence = this.setCSVSequence(csvBlocks, this.sequence);
+            }
+        }
+    }
+
+    protected secondsToCSVTimeUnits(seconds: number): number {
+        return Math.floor(seconds / 512);
+    }
+
+    protected createTimeBasedCSV(seconds: number): number {
+        const timeUnits = this.secondsToCSVTimeUnits(seconds);
+        if (timeUnits > 0xffff) {
+            throw new Error(`Time units ${timeUnits} exceeds maximum of 65,535`);
+        }
+        return timeUnits | (1 << 22);
+    }
+
+    protected isCSVEnabled(sequence: number): boolean {
+        return (sequence & (1 << 31)) === 0;
+    }
+
+    protected extractCSVValue(sequence: number): number {
+        return sequence & 0x0000ffff;
+    }
+
     protected customFinalizerP2SH = (
         inputIndex: number,
         input: PsbtInput,
@@ -858,6 +944,38 @@ export abstract class TweakedTransaction extends Logger {
             };
         }
 
+        if (this.anchorInputIndices.has(inputIndex)) {
+            return {
+                finalScriptSig: undefined,
+                finalScriptWitness: Buffer.from([0]),
+            };
+        }
+
+        if (isP2WSH && isSegwit && input.witnessScript) {
+            if (!input.partialSig || input.partialSig.length === 0) {
+                throw new Error(`No signatures for P2WSH input #${inputIndex}`);
+            }
+
+            const isP2WDA = P2WDADetector.isP2WDAWitnessScript(input.witnessScript);
+            if (isP2WDA) {
+                return this.finalizeSecondaryP2WDA(inputIndex, input);
+            }
+
+            // Check if this is a CSV input
+            const isCSVInput = this.csvInputIndices.has(inputIndex);
+            if (isCSVInput) {
+                // For CSV P2WSH, the witness stack should be: [signature, witnessScript]
+                const witnessStack = [input.partialSig[0].signature, input.witnessScript];
+                return {
+                    finalScriptSig: undefined,
+                    finalScriptWitness:
+                        TransactionBuilder.witnessStackToScriptWitness(witnessStack),
+                };
+            }
+
+            // For non-CSV P2WSH, use default finalization
+        }
+
         return getFinalScripts(
             inputIndex,
             input,
@@ -870,6 +988,35 @@ export abstract class TweakedTransaction extends Logger {
         );
     };
 
+    /**
+     * Finalize secondary P2WDA inputs with empty data
+     */
+    protected finalizeSecondaryP2WDA(
+        inputIndex: number,
+        input: PsbtInput,
+    ): {
+        finalScriptWitness: Buffer | undefined;
+        finalScriptSig: Buffer | undefined;
+    } {
+        if (!input.partialSig || input.partialSig.length === 0) {
+            throw new Error(`No signature for P2WDA input #${inputIndex}`);
+        }
+
+        if (!input.witnessScript) {
+            throw new Error(`No witness script for P2WDA input #${inputIndex}`);
+        }
+
+        const witnessStack = P2WDADetector.createSimpleP2WDAWitness(
+            input.partialSig[0].signature,
+            input.witnessScript,
+        );
+
+        return {
+            finalScriptSig: undefined,
+            finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness(witnessStack),
+        };
+    }
+
     protected async signInputsWalletBased(transaction: Psbt): Promise<void> {
         const signer: UnisatSigner = this.signer as UnisatSigner;
 
@@ -884,6 +1031,82 @@ export abstract class TweakedTransaction extends Logger {
         this.finalized = true;
     }
 
+    protected isCSVScript(decompiled: (number | Buffer)[]): boolean {
+        return decompiled.some((op) => op === opcodes.OP_CHECKSEQUENCEVERIFY);
+    }
+
+    protected setCSVSequence(csvBlocks: number, currentSequence: number): number {
+        if (this.txVersion < 2) {
+            throw new Error('CSV requires transaction version 2 or higher');
+        }
+
+        if (csvBlocks > 0xffff) {
+            throw new Error(`CSV blocks ${csvBlocks} exceeds maximum of 65,535`);
+        }
+
+        // Layout of nSequence field (32 bits) when CSV is active (bit 31 = 0):
+        // Bit 31: Must be 0 (CSV enable flag)
+        // Bits 23-30: Unused by BIP68 (available for custom use)
+        // Bit 22: Time flag (0 = blocks, 1 = time)
+        // Bits 16-21: Unused by BIP68 (available for custom use)
+        // Bits 0-15: CSV lock-time value
+
+        // Extract the time flag if it's set in csvBlocks
+        const isTimeBased = (csvBlocks & (1 << 22)) !== 0;
+
+        // Start with the CSV value
+        let sequence = csvBlocks & 0x0000ffff;
+
+        // Preserve the time flag if set
+        if (isTimeBased) {
+            sequence |= 1 << 22;
+        }
+
+        if (currentSequence === (TransactionSequence.REPLACE_BY_FEE as number)) {
+            // Set bit 25 as our explicit RBF flag
+            // This is in the unused range (bits 23-30) when CSV is active
+            sequence |= 1 << 25;
+
+            // We could use other unused bits for version/features
+            // sequence |= (1 << 26); // Could indicate tx flags if we wanted
+        }
+
+        // Final safety check: ensure bit 31 is 0 (CSV enabled)
+        sequence = sequence & 0x7fffffff;
+
+        return sequence;
+    }
+
+    protected getCSVType(csvValue: number): CSVModes {
+        // Bit 22 determines if it's time-based (1) or block-based (0)
+        return csvValue & (1 << 22) ? CSVModes.TIMESTAMPS : CSVModes.BLOCKS;
+    }
+
+    private extractCSVBlocks(decompiled: (number | Buffer)[]): number {
+        for (let i = 0; i < decompiled.length; i++) {
+            if (decompiled[i] === opcodes.OP_CHECKSEQUENCEVERIFY && i > 0) {
+                const csvValue = decompiled[i - 1];
+                if (Buffer.isBuffer(csvValue)) {
+                    return script.number.decode(csvValue);
+                } else if (typeof csvValue === 'number') {
+                    // Handle OP_N directly
+                    if (csvValue === opcodes.OP_0 || csvValue === opcodes.OP_FALSE) {
+                        return 0;
+                    } else if (csvValue === opcodes.OP_1NEGATE) {
+                        return -1;
+                    } else if (csvValue >= opcodes.OP_1 && csvValue <= opcodes.OP_16) {
+                        return csvValue - opcodes.OP_1 + 1;
+                    } else {
+                        // For other numbers, they should have been Buffers
+                        // This shouldn't happen in properly decompiled scripts
+                        throw new Error(`Unexpected raw number in script: ${csvValue}`);
+                    }
+                }
+            }
+        }
+        return 0;
+    }
+
     private async attemptSignTaproot(
         transaction: Psbt,
         input: PsbtInput,