@btc-vision/transaction 1.6.1 → 1.6.5

package/build/transaction/shared/TweakedTransaction.js

@@ -1,12 +1,21 @@
 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';
+import { Buffer } from 'buffer';
+import { P2WDADetector } from '../../p2wda/P2WDADetector.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 +28,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 +44,29 @@ 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 isP2WDA = P2WDADetector.isP2WDAWitnessScript(input.witnessScript);
+                if (isP2WDA) {
+                    return this.finalizeSecondaryP2WDA(inputIndex, input);
+                }
+                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 +75,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 +158,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 +198,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 +378,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 +398,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 +439,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 +454,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 +481,53 @@ 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;
+    }
+    finalizeSecondaryP2WDA(inputIndex, input) {
+        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),
+        };
+    }
     async signInputsWalletBased(transaction) {
         const signer = this.signer;
         await signer.multiSignPsbt([transaction]);
@@ -449,6 +536,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/doc/addresses/P2OP.md

@@ -0,0 +1 @@
+

package/doc/addresses/P2WDA.md

@@ -0,0 +1,240 @@
+# Pay-to-Witness-Data-Authentication (P2WDA)
+
+## Executive Summary
+
+Bitcoin makes arbitrary authenticated data inclusion expensive unless you exploit the SegWit witness discount, where
+every witness byte weighs 1 unit instead of 4. P2WDA is a spend template that deliberately carries authenticated
+application data in witness stack items and then drops them before a standard signature check. This preserves standard
+Bitcoin validation while letting applications verify the attached data out-of-band.
+
+In this implementation, the witness stack reserves **10 data slots** per P2WDA input, each **≤80 bytes** to respect
+default relay policy. The data (after compression) is prefixed by a **BIP340 Schnorr** signature over
+`(tx_signature || uncompressed_data)`, then split across those slots. Applications reassemble and verify the signed
+data, making any miner tampering detectable. On-chain validation remains standard and cheap thanks to the witness
+discount.
+
+## 1. Problem Space
+
+### 1.1 The Traditional Dilemma
+
+OP_RETURN is simple but tiny: **80 bytes max** per output under standard policy. Anything larger forces many outputs and
+multiple transactions, compounding base (non-witness) bytes that weigh 4× witness bytes. For realistic payloads (
+airdrops, rich metadata), this is cost-prohibitive.
+
+Importantly, even if OP_RETURN size limits were completely removed, it would not solve the fundamental economic problem.
+OP_RETURN data is stored in the transaction's output section, which means every byte counts as non-witness data and
+incurs the full 4× weight penalty. A hypothetical uncapped OP_RETURN storing 800 bytes would cost 3,200 weight units,
+while P2WDA achieves the same data storage for only 800 weight units in the witness section. The economic disadvantage
+of OP_RETURN is architectural, not merely a policy limitation.
+
+Commit-reveal styles fix integrity but double touches the chain (commit tx, reveal tx) and fragment UX.
+
+### 1.2 The Witness Discount Opportunity
+
+SegWit introduced **weight**: non-witness bytes weigh 4 units each; witness bytes weigh **1**. Fees are proportional to
+weight (vbytes ≈ weight/4). Packing authenticated data into witness can be ~75% cheaper than encoding the same data in
+base tx bytes.
+
+## 2. Technical Architecture
+
+### 2.1 Spend Template
+
+P2WDA uses a **P2WSH** spend whose script pre-drops a fixed number of stack items (the data slots), then performs a
+standard single-sig check.
+
+The witness script consists of:
+
+- 5 consecutive `OP_2DROP` operations (dropping 10 items total)
+- A 33-byte compressed public key
+- An `OP_CHECKSIG` operation
+
+This creates a script of approximately 40 bytes that validates like any standard single-signature P2WSH spend, but with
+space for our data payload in the witness stack.
+
+### 2.2 Authentication & Packing
+
+The authentication and packing process ensures data integrity while maximizing compression efficiency. Here's how it
+works:
+
+**Step 1: Prepare the data**
+
+- Start with your uncompressed payload data (application bytes)
+- Get the transaction signature (the DER signature that authorizes spending this input)
+
+**Step 2: Create authentication signature**
+
+- Compute a BIP340 Schnorr signature over the hash of (transaction_signature || payload_data)
+- This signature proves authorship and binds the data to this specific spend
+
+**Step 3: Combine and compress**
+
+```ts
+// Combine the authentication signature with the payload
+const combined_bytes = data_signature + payload_data;
+
+// Compress everything using DEFLATE or similar
+const compressed_bytes = COMPRESS(combined_bytes);
+
+// Split into chunks of max 80 bytes each
+const chunks = SPLIT_INTO_80_BYTE_CHUNKS(compressed_bytes);
+
+// Ensure we don't exceed 10 chunks
+if (chunks.length > 10) {
+    throw Error("Payload too large")
+}
+```
+
+**Step 4: Build the witness stack**
+The witness stack must contain exactly 12 items in this order:
+
+1. Data slot 0 (up to 80 bytes, or empty)
+2. Data slot 1 (up to 80 bytes, or empty)
+3. ... through Data slot 9
+4. Transaction signature (DER encoded, ~72 bytes)
+5. Witness script (~40 bytes)
+
+Any unused data slots are filled with empty byte arrays (length 0) to maintain the expected stack structure.
+
+**Verification Process for Indexers:**
+
+When an indexer encounters a P2WDA spend, it:
+
+1. Extracts and concatenates the first 10 witness items
+2. Decompresses the result to get (data_signature || original_data)
+3. Verifies the Schnorr signature against hash(tx_signature || original_data)
+4. If valid, passes the original_data to the application layer
+
+This design ensures that while Bitcoin consensus never inspects the data, any tampering is cryptographically detectable
+by applications.
+
+### 2.3 Input Placement Rules
+
+To simplify parsing and minimize duplication:
+
+* **All application data must be injected in the first P2WDA input by index** (the lowest-index input spending a P2WDA
+  UTXO)
+* Any **additional P2WDA inputs** in the same tx must supply **10 empty data items** (length=0) in their witness
+* Non-P2WDA inputs are unaffected
+* If a transaction flagged as `InteractionTransactionP2WDA` spends **no** P2WDA UTXOs, **throw an error**
+
+## 3. Economics
+
+### 3.1 OP_RETURN Baseline
+
+Standard OP_RETURN script is ≤83 bytes total, allowing ≤80 bytes data. All bytes are non-witness, costing **1 vbyte per
+byte**. For 80 bytes of data you typically consume ~91 vbytes including script overhead and output framing.
+
+### 3.2 P2WDA Spend
+
+The witness bytes calculation for a P2WDA input includes:
+
+- 1 byte for item count
+- 10 bytes for length prefixes (one per data slot)
+- The actual compressed data bytes
+- ~73 bytes for the transaction signature (including length prefix)
+- ~41 bytes for the witness script (including length prefix)
+
+Since all of this is witness data, it costs only 1/4 the weight of equivalent non-witness bytes.
+
+**Example with 512 bytes of incompressible data:**
+
+- Data + signature = 576 bytes total
+- Split across 8 slots (72 bytes each)
+- Total witness bytes ≈ 701
+- Cost in vbytes ≈ 175
+
+Compare to OP_RETURN which would need 7 outputs at ~91 vbytes each ≈ 637 vbytes.
+**Result: ~72% savings** while keeping everything in a single transaction.
+
+## 4. Security Model
+
+The security model separates on-chain authorization from off-chain data authentication:
+
+* **On-chain authorization**: The transaction signature proves spend authorization exactly like any P2WSH single-sig
+  spend
+* **Off-chain authorship**: The Schnorr signature authenticates the data and binds it to this spend via the transaction
+  signature
+* **Malleability handling**: SegWit allows witness data modification without changing the txid. The Schnorr signature
+  ensures any tampering is detectable
+
+Practical outcomes:
+
+- Funds cannot be redirected (protected by transaction signature)
+- Data forgery is detectable at the application layer (Schnorr signature fails)
+- Miners could theoretically replace data with garbage, but applications will reject it
+
+## 5. Operational Capabilities
+
+P2WDA works well for:
+
+* Mints
+* Airdrops
+* NFTs
+* Batch updates and state checkpoints
+* Governance votes and attestations
+* Swap listings (like nativeswap) but **NOT TRADES**, a miner could cancel your transaction!
+* etc.
+
+The 10 slots serve as a transport layer; keep application formats versioned and compact.
+
+## 6. Advanced Considerations
+
+### 6.1 Why 10 Slots of ≤80 Bytes?
+
+Default relay policy limits:
+
+- Maximum 100 stack items for P2WSH
+- Maximum 80 bytes per non-script witness item
+- Maximum 3600 bytes for the witness script itself
+
+Ten slots provides headroom while keeping scripts simple (5 * OP_2DROP). You can scale by using multiple P2WDA inputs,
+keeping data only in the first P2WDA input and zeros in the rest.
+
+### 6.2 Domain Separation (Recommended)
+
+To harden against cross-protocol attacks, consider using domain separation:
+
+```
+message = Hash("P2WDA/v1" || txid || input_index || tx_signature || data)
+data_signature = Schnorr.Sign(auth_private_key, message)
+```
+
+This prevents signatures from being reused across different protocols or transactions.
+
+### 6.3 Compression
+
+Use a standard compression algorithm like DEFLATE to maximize data packing efficiency. Ensure your application layer
+can handle decompression and verify the integrity of the decompressed data.
+
+### 6.4 Why SegWit Instead of Taproot?
+
+A common question is why P2WDA uses SegWit's P2WSH instead of the newer Taproot technology. This decision is deliberate
+and based on fundamental economics of block space usage. Understanding this choice illuminates the elegant design of
+P2WDA.
+
+#### The Block Space Reality
+
+When people first hear about P2WDA, they might assume it should use Taproot since it's Bitcoin's newest upgrade.
+However, Taproot would actually consume more block space for our use case, making it less efficient. This
+counterintuitive reality stems from how these technologies were designed for different purposes.
+
+Taproot offers two spending paths. The key path is remarkably efficient, requiring only a 64-byte Schnorr signature, but
+it cannot carry arbitrary data. To include data, you must use the script path, which requires a control block containing
+the internal public key, parity information, and Merkle proof of your script's inclusion in the taproot tree. Even with
+the simplest possible tree structure, this control block adds approximately 65 bytes of pure overhead.
+
+Let's examine the concrete numbers for storing 500 bytes of authenticated data:
+
+With P2WSH (what P2WDA uses), the witness contains the transaction signature (~72 bytes), your data (500 bytes), and the
+witness script (~40 bytes), totaling approximately 612 bytes, which equals 612 weight units.
+
+With Taproot's script path, you would need a Schnorr signature (64 bytes), your data (500 bytes), the tapscript (~40
+bytes), and the control block (~65 bytes), totaling approximately 669 bytes, which equals 669 weight units.
+
+This represents about 10% more block space consumption for identical functionality. When your goal is cost-efficient
+data storage, every byte matters, and this overhead directly translates to higher fees for users.
+
+### 6.4 Future Extensions
+
+- Use annexes (BIP490) to carry larger payloads if needed and stop requiring another signature in the witness stack
+- Explore multi-signature variants for collaborative data signing

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@btc-vision/transaction",
     "type": "module",
-    "version": "1.6.1",
+    "version": "1.6.5",
     "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.5';

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);
     }