@btc-vision/transaction 1.6.0 → 1.6.4

package/src/transaction/builders/TransactionBuilder.ts

@@ -28,6 +28,7 @@ initEccLib(ecc);
 
 export const MINIMUM_AMOUNT_REWARD: bigint = 540n;
 export const MINIMUM_AMOUNT_CA: bigint = 297n;
+export const ANCHOR_SCRIPT = Buffer.from('51024e73', 'hex');
 
 /**
  * Allows to build a transaction like you would on Ethereum.
@@ -148,6 +149,12 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
      */
     protected isPubKeyDestination: boolean;
 
+    /**
+     * @description If the transaction need an anchor output
+     * @protected
+     */
+    protected anchor: boolean;
+
     protected note?: Buffer;
 
     protected constructor(parameters: ITransactionParameters) {
@@ -174,6 +181,8 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
             }
         }
 
+        this.anchor = parameters.anchor ?? false;
+
         this.isPubKeyDestination = this.to
             ? AddressVerificator.isValidPublicKey(this.to, this.network)
             : false;
@@ -191,6 +200,7 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
 
         this.transaction = new Psbt({
             network: this.network,
+            version: this.txVersion,
         });
     }
 
@@ -247,6 +257,13 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
         });
     }
 
+    public addAnchor(): void {
+        this.addOutput({
+            value: 0,
+            script: ANCHOR_SCRIPT,
+        });
+    }
+
     public async getFundingTransactionParameters(): Promise<IFundingTransactionParameters> {
         if (!this.estimatedFees) {
             this.estimatedFees = await this.estimateTransactionFees();
@@ -400,8 +417,10 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
                 throw new Error('Output script is too short');
             }
 
-            if (script.script[0] !== opcodes.OP_RETURN) {
-                throw new Error('Output script must start with OP_RETURN when value is 0');
+            if (script.script[0] !== opcodes.OP_RETURN && !script.script.equals(ANCHOR_SCRIPT)) {
+                throw new Error(
+                    'Output script must start with OP_RETURN or be an ANCHOR when value is 0',
+                );
             }
         } else if (output.value < TransactionBuilder.MINIMUM_DUST) {
             throw new Error(
@@ -462,7 +481,11 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
     }
 
     public async rebuildFromBase64(base64: string): Promise<Psbt> {
-        this.transaction = Psbt.fromBase64(base64, { network: this.network });
+        this.transaction = Psbt.fromBase64(base64, {
+            network: this.network,
+            version: this.txVersion,
+        });
+
         this.signed = false;
 
         this.sighashTypes = [Transaction.SIGHASH_ANYONECANPAY, Transaction.SIGHASH_ALL];
@@ -517,6 +540,10 @@ export abstract class TransactionBuilder<T extends TransactionType> extends Twea
             this.addOPReturn(this.note);
         }
 
+        if (this.anchor) {
+            this.addAnchor();
+        }
+
         /** Add the refund output */
         const sendBackAmount: bigint = this.totalInputAmount - amountSpent;
         if (sendBackAmount >= TransactionBuilder.MINIMUM_DUST) {

package/src/transaction/interfaces/ITransactionParameters.ts

@@ -24,6 +24,7 @@ export interface ITransactionParameters extends ITweakedTransactionData {
     noSignatures?: boolean;
 
     readonly note?: string | Buffer;
+    readonly anchor?: boolean;
 
     readonly feeRate: number;
     readonly priorityFee: bigint;

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,9 @@ import {
     isTaprootInput,
     pubkeyInScript,
 } from '../../signer/SignerUtils.js';
+import { TransactionBuilder } from '../builders/TransactionBuilder.js';
+
+export type SupportedTransactionVersion = 1 | 2 | 3;
 
 export interface ITweakedTransactionData {
     readonly signer: Signer | ECPairInterface | UnisatSigner;
@@ -46,6 +49,7 @@ export interface ITweakedTransactionData {
     readonly nonWitnessUtxo?: Buffer;
     readonly noSignatures?: boolean;
     readonly unlockScript?: Buffer[];
+    readonly txVersion?: SupportedTransactionVersion;
 }
 
 /**
@@ -56,6 +60,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 +99,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 +145,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 +170,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 +334,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 +438,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 +710,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 +718,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 +736,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 +799,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 +809,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 +823,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 +870,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 +942,33 @@ 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}`);
+            }
+
+            // 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,
@@ -884,6 +995,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,

package/src/utxo/OPNetLimitedProvider.ts

@@ -14,10 +14,6 @@ export interface WalletUTXOs {
     readonly spentTransactions: RawUTXOResponse[];
 }
 
-export interface PreimageData {
-    readonly preimage: Buffer;
-}
-
 /**
  * Allows to fetch UTXO data from any OPNET node
  */
@@ -181,19 +177,6 @@ export class OPNetLimitedProvider {
         return result as BroadcastResponse;
     }
 
-    /**
-     * Fetches the preimage from the OPNET node
-     * @returns {Promise<PreimageData | undefined>} - The preimage fetched
-     */
-    public async getPreimage(): Promise<PreimageData | undefined> {
-        const result = await this.rpcMethod('btc_preimage', []);
-        if (!result) {
-            return;
-        }
-
-        return result as PreimageData;
-    }
-
     /**
      * Splits UTXOs into smaller UTXOs
      * @param {Wallet} wallet - The wallet to split UTXOs