@btc-vision/transaction 1.6.1 → 1.6.4

package/build/transaction/shared/TweakedTransaction.js

@@ -1,12 +1,19 @@
 import { Logger } from '@btc-vision/logger';
-import { address as bitAddress, crypto as bitCrypto, getFinalScripts, isP2MS, isP2PK, isP2PKH, isP2SHScript, isP2TR, isP2WPKH, isP2WSHScript, isUnknownSegwitVersion, opcodes, payments, PaymentType, script, toXOnly, varuint, } from '@btc-vision/bitcoin';
+import { address as bitAddress, crypto as bitCrypto, getFinalScripts, isP2A, isP2MS, isP2PK, isP2PKH, isP2SHScript, isP2TR, isP2WPKH, isP2WSHScript, isUnknownSegwitVersion, opcodes, payments, PaymentType, script, toXOnly, varuint, } from '@btc-vision/bitcoin';
 import { TweakedSigner } from '../../signer/TweakedSigner.js';
 import { canSignNonTaprootInput, isTaprootInput, pubkeyInScript, } from '../../signer/SignerUtils.js';
+import { TransactionBuilder } from '../builders/TransactionBuilder.js';
 export var TransactionSequence;
 (function (TransactionSequence) {
     TransactionSequence[TransactionSequence["REPLACE_BY_FEE"] = 4294967293] = "REPLACE_BY_FEE";
     TransactionSequence[TransactionSequence["FINAL"] = 4294967295] = "FINAL";
 })(TransactionSequence || (TransactionSequence = {}));
+export var CSVModes;
+(function (CSVModes) {
+    CSVModes[CSVModes["BLOCKS"] = 0] = "BLOCKS";
+    CSVModes[CSVModes["TIMESTAMPS"] = 1] = "TIMESTAMPS";
+})(CSVModes || (CSVModes = {}));
+const CSV_ENABLED_BLOCKS_MASK = 0x3fffffff;
 export class TweakedTransaction extends Logger {
     constructor(data) {
         super();
@@ -19,9 +26,12 @@ export class TweakedTransaction extends Logger {
         this.sequence = TransactionSequence.REPLACE_BY_FEE;
         this.tapLeafScript = null;
         this.isBrowser = false;
+        this.csvInputIndices = new Set();
+        this.anchorInputIndices = new Set();
         this.regenerated = false;
         this.ignoreSignatureErrors = false;
         this.noSignatures = false;
+        this.txVersion = 2;
         this.customFinalizerP2SH = (inputIndex, input, scriptA, isSegwit, isP2SH, isP2WSH) => {
             const inputDecoded = this.inputs[inputIndex];
             if (isP2SH && input.partialSig && inputDecoded && inputDecoded.redeemScript) {
@@ -32,6 +42,25 @@ export class TweakedTransaction extends Logger {
                     finalScriptWitness: undefined,
                 };
             }
+            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 isCSVInput = this.csvInputIndices.has(inputIndex);
+                if (isCSVInput) {
+                    const witnessStack = [input.partialSig[0].signature, input.witnessScript];
+                    return {
+                        finalScriptSig: undefined,
+                        finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness(witnessStack),
+                    };
+                }
+            }
             return getFinalScripts(inputIndex, input, scriptA, isSegwit, isP2SH, isP2WSH, true, this.unlockScript);
         };
         this.signer = data.signer;
@@ -40,6 +69,9 @@ export class TweakedTransaction extends Logger {
         this.nonWitnessUtxo = data.nonWitnessUtxo;
         this.unlockScript = data.unlockScript;
         this.isBrowser = typeof window !== 'undefined';
+        if (data.txVersion) {
+            this.txVersion = data.txVersion;
+        }
     }
     static readScriptWitnessToWitnessStack(Buffer) {
         let offset = 0;
@@ -120,6 +152,9 @@ export class TweakedTransaction extends Logger {
             throw new Error('Transaction is already signed');
         this.sequence = TransactionSequence.FINAL;
         for (const input of this.inputs) {
+            if (this.csvInputIndices.has(this.inputs.indexOf(input))) {
+                continue;
+            }
             input.sequence = TransactionSequence.FINAL;
         }
     }
@@ -157,6 +192,8 @@ export class TweakedTransaction extends Logger {
         return this.signer;
     }
     async signInput(transaction, input, i, signer, reverse = false, errored = false) {
+        if (this.anchorInputIndices.has(i))
+            return;
         const publicKey = signer.publicKey;
         let isTaproot = isTaprootInput(input);
         if (reverse) {
@@ -335,17 +372,17 @@ export class TweakedTransaction extends Logger {
         return;
     }
     generatePsbtInputExtended(utxo, i, _extra = false) {
-        const script = Buffer.from(utxo.scriptPubKey.hex, 'hex');
+        const scriptPub = Buffer.from(utxo.scriptPubKey.hex, 'hex');
         const input = {
             hash: utxo.transactionId,
             index: utxo.outputIndex,
             sequence: this.sequence,
             witnessUtxo: {
                 value: Number(utxo.value),
-                script,
+                script: scriptPub,
             },
         };
-        if (isP2PKH(script)) {
+        if (isP2PKH(scriptPub)) {
             if (utxo.nonWitnessUtxo) {
                 input.nonWitnessUtxo = Buffer.isBuffer(utxo.nonWitnessUtxo)
                     ? utxo.nonWitnessUtxo
@@ -355,17 +392,12 @@ export class TweakedTransaction extends Logger {
                 throw new Error('Missing nonWitnessUtxo for P2PKH UTXO');
             }
         }
-        else if (isP2WPKH(script) || isUnknownSegwitVersion(script)) {
+        else if (isP2WPKH(scriptPub) || isUnknownSegwitVersion(scriptPub)) {
         }
-        else if (isP2WSHScript(script)) {
-            if (!utxo.witnessScript) {
-                throw new Error('Missing witnessScript for P2WSH UTXO');
-            }
-            input.witnessScript = Buffer.isBuffer(utxo.witnessScript)
-                ? utxo.witnessScript
-                : Buffer.from(utxo.witnessScript, 'hex');
+        else if (isP2WSHScript(scriptPub)) {
+            this.processP2WSHInput(utxo, input, i);
         }
-        else if (isP2SHScript(script)) {
+        else if (isP2SHScript(scriptPub)) {
             let redeemScriptBuf;
             if (utxo.redeemScript) {
                 redeemScriptBuf = Buffer.isBuffer(utxo.redeemScript)
@@ -401,15 +433,13 @@ export class TweakedTransaction extends Logger {
             }
             else if (isP2WSHScript(redeemOutput)) {
                 delete input.nonWitnessUtxo;
-                if (!input.witnessScript) {
-                    throw new Error('Missing witnessScript for P2SH-P2WSH UTXO');
-                }
+                this.processP2WSHInput(utxo, input, i);
             }
             else {
                 delete input.witnessUtxo;
             }
         }
-        else if (isP2TR(script)) {
+        else if (isP2TR(scriptPub)) {
             if (this.sighashTypes) {
                 const inputSign = TweakedTransaction.calculateSignHash(this.sighashTypes);
                 if (inputSign)
@@ -418,7 +448,11 @@ export class TweakedTransaction extends Logger {
             this.tweakSigner();
             input.tapInternalKey = this.internalPubKeyToXOnly();
         }
-        else if (isP2PK(script) || isP2MS(script)) {
+        else if (isP2A(scriptPub)) {
+            this.anchorInputIndices.add(i);
+            input.isPayToAnchor = true;
+        }
+        else if (isP2PK(scriptPub) || isP2MS(scriptPub)) {
             if (utxo.nonWitnessUtxo) {
                 input.nonWitnessUtxo = Buffer.isBuffer(utxo.nonWitnessUtxo)
                     ? utxo.nonWitnessUtxo
@@ -441,6 +475,40 @@ export class TweakedTransaction extends Logger {
         }
         return input;
     }
+    processP2WSHInput(utxo, input, i) {
+        if (!utxo.witnessScript) {
+            throw new Error('Missing witnessScript for P2WSH UTXO');
+        }
+        input.witnessScript = Buffer.isBuffer(utxo.witnessScript)
+            ? utxo.witnessScript
+            : Buffer.from(utxo.witnessScript, 'hex');
+        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);
+                const csvBlocks = this.extractCSVBlocks(decompiled);
+                console.log('csvBlocks', csvBlocks);
+                input.sequence = this.setCSVSequence(csvBlocks, this.sequence);
+            }
+        }
+    }
+    secondsToCSVTimeUnits(seconds) {
+        return Math.floor(seconds / 512);
+    }
+    createTimeBasedCSV(seconds) {
+        const timeUnits = this.secondsToCSVTimeUnits(seconds);
+        if (timeUnits > 0xffff) {
+            throw new Error(`Time units ${timeUnits} exceeds maximum of 65,535`);
+        }
+        return timeUnits | (1 << 22);
+    }
+    isCSVEnabled(sequence) {
+        return (sequence & (1 << 31)) === 0;
+    }
+    extractCSVValue(sequence) {
+        return sequence & 0x0000ffff;
+    }
     async signInputsWalletBased(transaction) {
         const signer = this.signer;
         await signer.multiSignPsbt([transaction]);
@@ -449,6 +517,55 @@ export class TweakedTransaction extends Logger {
         }
         this.finalized = true;
     }
+    isCSVScript(decompiled) {
+        return decompiled.some((op) => op === opcodes.OP_CHECKSEQUENCEVERIFY);
+    }
+    setCSVSequence(csvBlocks, currentSequence) {
+        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`);
+        }
+        const isTimeBased = (csvBlocks & (1 << 22)) !== 0;
+        let sequence = csvBlocks & 0x0000ffff;
+        if (isTimeBased) {
+            sequence |= 1 << 22;
+        }
+        if (currentSequence === TransactionSequence.REPLACE_BY_FEE) {
+            sequence |= 1 << 25;
+        }
+        sequence = sequence & 0x7fffffff;
+        return sequence;
+    }
+    getCSVType(csvValue) {
+        return csvValue & (1 << 22) ? CSVModes.TIMESTAMPS : CSVModes.BLOCKS;
+    }
+    extractCSVBlocks(decompiled) {
+        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') {
+                    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 {
+                        throw new Error(`Unexpected raw number in script: ${csvValue}`);
+                    }
+                }
+            }
+        }
+        return 0;
+    }
     async attemptSignTaproot(transaction, input, i, signer, publicKey) {
         const isScriptSpend = this.isTaprootScriptSpend(input, publicKey);
         if (isScriptSpend) {

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@btc-vision/transaction",
     "type": "module",
-    "version": "1.6.1",
+    "version": "1.6.4",
     "author": "BlobMaster41",
     "description": "OPNet transaction library allows you to create and sign transactions for the OPNet network.",
     "engines": {
@@ -89,7 +89,7 @@
     "dependencies": {
         "@babel/plugin-proposal-object-rest-spread": "^7.21.4-esm",
         "@bitcoinerlab/secp256k1": "^1.2.0",
-        "@btc-vision/bitcoin": "^6.4.6",
+        "@btc-vision/bitcoin": "^6.4.8",
         "@btc-vision/bitcoin-rpc": "^1.0.2",
         "@btc-vision/logger": "^1.0.6",
         "@eslint/js": "^9.32.0",

package/src/_version.ts

@@ -1 +1 @@
-export const version = '1.6.1';
+export const version = '1.6.4';

package/src/epoch/ChallengeSolution.ts

@@ -90,7 +90,7 @@ export class ChallengeSolution implements IChallengeSolution {
     /**
      * Static method to validate from raw data directly
      */
-    public static async validateRaw(data: RawChallenge): Promise<boolean> {
+    public static validateRaw(data: RawChallenge): boolean {
         return EpochValidator.validateEpochWinner(data);
     }
 
@@ -116,9 +116,9 @@ export class ChallengeSolution implements IChallengeSolution {
 
     /**
      * Verify this challenge
-     * @returns {Promise<boolean>} True if the challenge is valid
+     * @returns {boolean} True if the challenge is valid
      */
-    public async verify(): Promise<boolean> {
+    public verify(): boolean {
         return EpochValidator.validateChallengeSolution(this);
     }
 
@@ -165,7 +165,7 @@ export class ChallengeSolution implements IChallengeSolution {
      * Calculate the expected solution hash for this challenge
      * @returns {Promise<Buffer>} The calculated solution hash
      */
-    public async calculateSolution(): Promise<Buffer> {
+    public calculateSolution(): Buffer {
         return EpochValidator.calculateSolution(
             this.verification.targetChecksum,
             this.publicKey.toBuffer(),

package/src/epoch/validator/EpochValidator.ts

@@ -1,9 +1,9 @@
 import { IChallengeSolution, RawChallenge } from '../interfaces/IChallengeSolution.js';
 import { ChallengeSolution } from '../ChallengeSolution.js';
+import { crypto } from '@btc-vision/bitcoin';
 
 export class EpochValidator {
     private static readonly BLOCKS_PER_EPOCH: bigint = 5n;
-    private static readonly GRAFFITI_LENGTH: number = 16;
 
     /**
      * Convert Buffer to Uint8Array
@@ -22,9 +22,8 @@ export class EpochValidator {
     /**
      * Calculate SHA-1 hash
      */
-    public static async sha1(data: Uint8Array): Promise<Uint8Array> {
-        const hashBuffer = await crypto.subtle.digest('SHA-1', data);
-        return new Uint8Array(hashBuffer);
+    public static sha1(data: Uint8Array | Buffer): Buffer {
+        return crypto.sha1(Buffer.isBuffer(data) ? data : Buffer.from(data));
     }
 
     /**
@@ -78,10 +77,7 @@ export class EpochValidator {
     /**
      * Verify an epoch solution using IPreimage
      */
-    public static async verifySolution(
-        challenge: IChallengeSolution,
-        log: boolean = false,
-    ): Promise<boolean> {
+    public static verifySolution(challenge: IChallengeSolution, log: boolean = false): boolean {
         try {
             const verification = challenge.verification;
             const calculatedPreimage = this.calculatePreimage(
@@ -90,7 +86,7 @@ export class EpochValidator {
                 challenge.salt,
             );
 
-            const computedSolution = await this.sha1(this.bufferToUint8Array(calculatedPreimage));
+            const computedSolution = this.sha1(calculatedPreimage);
             const computedSolutionBuffer = this.uint8ArrayToBuffer(computedSolution);
 
             if (!computedSolutionBuffer.equals(challenge.solution)) {
@@ -134,16 +130,16 @@ export class EpochValidator {
     /**
      * Validate epoch winner from raw data
      */
-    public static async validateEpochWinner(epochData: RawChallenge): Promise<boolean> {
+    public static validateEpochWinner(epochData: RawChallenge): boolean {
         const preimage = new ChallengeSolution(epochData);
-        return await this.verifySolution(preimage);
+        return this.verifySolution(preimage);
     }
 
     /**
      * Validate epoch winner from Preimage instance
      */
-    public static async validateChallengeSolution(challenge: IChallengeSolution): Promise<boolean> {
-        return await this.verifySolution(challenge);
+    public static validateChallengeSolution(challenge: IChallengeSolution): boolean {
+        return this.verifySolution(challenge);
     }
 
     /**
@@ -153,13 +149,13 @@ export class EpochValidator {
      * @param salt The salt buffer (32 bytes)
      * @returns The SHA-1 hash of the preimage
      */
-    public static async calculateSolution(
+    public static calculateSolution(
         targetChecksum: Buffer,
         publicKey: Buffer,
         salt: Buffer,
-    ): Promise<Buffer> {
+    ): Buffer {
         const preimage = this.calculatePreimage(targetChecksum, publicKey, salt);
-        const hash = await this.sha1(this.bufferToUint8Array(preimage));
+        const hash = this.sha1(this.bufferToUint8Array(preimage));
         return this.uint8ArrayToBuffer(hash);
     }
 

package/src/keypair/AddressVerificator.ts

@@ -12,6 +12,7 @@ export enum AddressTypes {
     P2PK = 'P2PK',
     P2TR = 'P2TR',
     P2WPKH = 'P2WPKH',
+    P2WSH = 'P2WSH',
 }
 
 export class AddressVerificator {
@@ -193,11 +194,16 @@ export class AddressVerificator {
             }
 
             if (decodedBech32.prefix === network.bech32) {
-                // P2WPKH: SegWit address (starting with 'bc1q' for mainnet, 'tb1q' for testnet)
+                // P2WPKH: SegWit address (20 bytes)
                 if (decodedBech32.version === 0 && decodedBech32.data.length === 20) {
                     return AddressTypes.P2WPKH;
                 }
 
+                // P2WSH: SegWit script hash (32 bytes)
+                if (decodedBech32.version === 0 && decodedBech32.data.length === 32) {
+                    return AddressTypes.P2WSH;
+                }
+
                 // P2TR: Taproot address (starting with 'bc1p' for mainnet, 'tb1p' for testnet)
                 if (decodedBech32.version === 1 && decodedBech32.data.length === 32) {
                     return AddressTypes.P2TR;

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;