@btc-vision/transaction 1.6.0 → 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/build/utxo/OPNetLimitedProvider.d.ts

@@ -7,9 +7,6 @@ export interface WalletUTXOs {
     readonly pending: RawUTXOResponse[];
     readonly spentTransactions: RawUTXOResponse[];
 }
-export interface PreimageData {
-    readonly preimage: Buffer;
-}
 export declare class OPNetLimitedProvider {
     private readonly opnetAPIUrl;
     private readonly utxoPath;
@@ -18,7 +15,6 @@ export declare class OPNetLimitedProvider {
     fetchUTXO(settings: FetchUTXOParams): Promise<UTXO[]>;
     fetchUTXOMultiAddr(settings: FetchUTXOParamsMultiAddress): Promise<UTXO[]>;
     broadcastTransaction(transaction: string, psbt: boolean): Promise<BroadcastResponse | undefined>;
-    getPreimage(): Promise<PreimageData | undefined>;
     splitUTXOs(wallet: Wallet, network: Network, splitInputsInto: number, amountPerUTXO: bigint): Promise<BroadcastResponse | {
         error: string;
     }>;

package/build/utxo/OPNetLimitedProvider.js

@@ -103,13 +103,6 @@ export class OPNetLimitedProvider {
         }
         return result;
     }
-    async getPreimage() {
-        const result = await this.rpcMethod('btc_preimage', []);
-        if (!result) {
-            return;
-        }
-        return result;
-    }
     async splitUTXOs(wallet, network, splitInputsInto, amountPerUTXO) {
         const utxoSetting = {
             addresses: [wallet.p2wpkh, wallet.p2tr],

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@btc-vision/transaction",
     "type": "module",
-    "version": "1.6.0",
+    "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.0';
+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);
     }
 
@@ -115,16 +115,16 @@ export class ChallengeSolution implements IChallengeSolution {
     }
 
     /**
-     * Verify this preimage
-     * @returns {Promise<boolean>} True if the preimage is valid
+     * Verify this challenge
+     * @returns {boolean} True if the challenge is valid
      */
-    public async verify(): Promise<boolean> {
-        return EpochValidator.validatePreimage(this);
+    public verify(): boolean {
+        return EpochValidator.validateChallengeSolution(this);
     }
 
     /**
-     * Get the preimage buffer (alias for solution)
-     * @returns {Buffer} The solution/preimage as a buffer
+     * Get the preimage challenge
+     * @returns {Buffer} The solution/challenge as a buffer
      */
     public toBuffer(): Buffer {
         return this.solution;
@@ -162,10 +162,10 @@ export class ChallengeSolution implements IChallengeSolution {
     }
 
     /**
-     * Calculate the expected solution hash for this preimage
+     * 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(),
@@ -174,7 +174,7 @@ export class ChallengeSolution implements IChallengeSolution {
     }
 
     /**
-     * Check if the preimage meets a specific difficulty requirement
+     * Check if the challenge meets a specific difficulty requirement
      * @param {number} minDifficulty The minimum difficulty required
      * @returns {Promise<{valid: boolean; difficulty: number}>} Validation result
      */

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,22 +77,19 @@ export class EpochValidator {
     /**
      * Verify an epoch solution using IPreimage
      */
-    public static async verifySolution(
-        preimage: IChallengeSolution,
-        log: boolean = false,
-    ): Promise<boolean> {
+    public static verifySolution(challenge: IChallengeSolution, log: boolean = false): boolean {
         try {
-            const verification = preimage.verification;
+            const verification = challenge.verification;
             const calculatedPreimage = this.calculatePreimage(
                 verification.targetChecksum,
-                preimage.publicKey.toBuffer(),
-                preimage.salt,
+                challenge.publicKey.toBuffer(),
+                challenge.salt,
             );
 
-            const computedSolution = await this.sha1(this.bufferToUint8Array(calculatedPreimage));
+            const computedSolution = this.sha1(calculatedPreimage);
             const computedSolutionBuffer = this.uint8ArrayToBuffer(computedSolution);
 
-            if (!computedSolutionBuffer.equals(preimage.solution)) {
+            if (!computedSolutionBuffer.equals(challenge.solution)) {
                 return false;
             }
 
@@ -102,11 +98,11 @@ export class EpochValidator {
                 verification.targetHash,
             );
 
-            if (matchingBits !== preimage.difficulty) {
+            if (matchingBits !== challenge.difficulty) {
                 return false;
             }
 
-            const expectedStartBlock = preimage.epochNumber * this.BLOCKS_PER_EPOCH;
+            const expectedStartBlock = challenge.epochNumber * this.BLOCKS_PER_EPOCH;
             const expectedEndBlock = expectedStartBlock + this.BLOCKS_PER_EPOCH - 1n;
 
             return !(
@@ -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 validatePreimage(preimage: IChallengeSolution): Promise<boolean> {
-        return await this.verifySolution(preimage);
+    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/generators/builders/DeploymentGenerator.ts

@@ -19,7 +19,7 @@ export class DeploymentGenerator extends Generator {
      * Compile a bitcoin script representing a contract deployment
      * @param {Buffer} contractBytecode - The contract bytecode
      * @param {Buffer} contractSalt - The contract salt
-     * @param {ChallengeSolution} preimage - The preimage for reward
+     * @param {ChallengeSolution} challenge - The challenge for reward
      * @param {bigint} maxPriority - The maximum priority for the contract
      * @param {Buffer} [calldata] - The calldata to be passed to the contract
      * @param {Feature<Features>[]} [features] - Optional features to include in the script
@@ -28,7 +28,7 @@ export class DeploymentGenerator extends Generator {
     public compile(
         contractBytecode: Buffer,
         contractSalt: Buffer,
-        preimage: ChallengeSolution,
+        challenge: ChallengeSolution,
         maxPriority: bigint,
         calldata?: Buffer,
         features?: Feature<Features>[],
@@ -36,7 +36,7 @@ export class DeploymentGenerator extends Generator {
         const asm = this.getAsm(
             contractBytecode,
             contractSalt,
-            preimage,
+            challenge,
             maxPriority,
             calldata,
             features,
@@ -57,7 +57,7 @@ export class DeploymentGenerator extends Generator {
     private getAsm(
         contractBytecode: Buffer,
         contractSalt: Buffer,
-        preimage: ChallengeSolution,
+        challenge: ChallengeSolution,
         maxPriority: bigint,
         calldata?: Buffer,
         features?: Feature<Features>[],
@@ -85,10 +85,10 @@ export class DeploymentGenerator extends Generator {
             opcodes.OP_TOALTSTACK,
 
             // CHALLENGE PREIMAGE FOR REWARD,
-            preimage.publicKey.originalPublicKeyBuffer(),
+            challenge.publicKey.originalPublicKeyBuffer(),
             opcodes.OP_TOALTSTACK,
 
-            preimage.solution,
+            challenge.solution,
             opcodes.OP_TOALTSTACK,
 
             this.xSenderPubKey,

package/src/generators/builders/LegacyCalldataGenerator.ts

@@ -52,7 +52,7 @@ export class LegacyCalldataGenerator extends Generator {
      * Compile an interaction bitcoin script
      * @param {Buffer} calldata - The calldata to use
      * @param {Buffer} contractSecret - The contract secret
-     * @param {Buffer} preimage - The preimage to use
+     * @param {Buffer} challenge - The challenge to use
      * @param {bigint} maxPriority - The maximum priority
      * @param {number[]} [features=[]] - The features to use (optional)
      * @returns {Buffer} - The compiled script
@@ -61,7 +61,7 @@ export class LegacyCalldataGenerator extends Generator {
     public compile(
         calldata: Buffer,
         contractSecret: Buffer,
-        preimage: Buffer,
+        challenge: Buffer,
         maxPriority: bigint,
         features: Feature<Features>[] = [],
     ): Buffer {
@@ -83,7 +83,7 @@ export class LegacyCalldataGenerator extends Generator {
             opcodes.OP_TOALTSTACK,
 
             // CHALLENGE PREIMAGE FOR REWARD,
-            preimage,
+            challenge,
             opcodes.OP_TOALTSTACK,
 
             this.senderPubKey,

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/TransactionFactory.ts

@@ -29,7 +29,7 @@ export interface DeploymentResult {
 
     readonly contractAddress: string;
     readonly contractPubKey: string;
-    readonly preimage: RawChallenge;
+    readonly challenge: RawChallenge;
 
     readonly utxos: UTXO[];
 }
@@ -52,7 +52,7 @@ export interface InteractionResponse {
     readonly interactionTransaction: string;
     readonly estimatedFees: bigint;
     readonly nextUTXOs: UTXO[];
-    readonly preimage: RawChallenge;
+    readonly challenge: RawChallenge;
 }
 
 export interface BitcoinTransferResponse extends BitcoinTransferBase {
@@ -253,7 +253,7 @@ export class TransactionFactory {
                 interactionParameters.from,
                 1,
             ), // always 1
-            preimage: preTransaction.getPreimage().toRaw(),
+            challenge: preTransaction.getPreimage().toRaw(),
         };
     }
 
@@ -358,7 +358,7 @@ export class TransactionFactory {
             contractAddress: finalTransaction.getContractAddress(), //finalTransaction.contractAddress.p2tr(deploymentParameters.network),
             contractPubKey: finalTransaction.contractPubKey,
             utxos: [refundUTXO],
-            preimage: preTransaction.getPreimage().toRaw(),
+            challenge: preTransaction.getPreimage().toRaw(),
         };
     }
 

package/src/transaction/builders/DeploymentTransaction.ts

@@ -36,7 +36,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
 
     public type: TransactionType.DEPLOYMENT = TransactionType.DEPLOYMENT;
 
-    protected readonly preimage: ChallengeSolution;
+    protected readonly challenge: ChallengeSolution;
     protected readonly epochChallenge: ITimeLockOutput;
 
     /**
@@ -128,10 +128,10 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
         if (!parameters.challenge) throw new Error('Challenge solution is required');
 
         this.randomBytes = parameters.randomBytes || BitcoinUtils.rndBytes();
-        this.preimage = parameters.challenge;
+        this.challenge = parameters.challenge;
 
         this.epochChallenge = TimeLockGenerator.generateTimeLockAddress(
-            this.preimage.publicKey.originalPublicKeyBuffer(),
+            this.challenge.publicKey.originalPublicKeyBuffer(),
             this.network,
         );
 
@@ -147,7 +147,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
         this.compiledTargetScript = this.deploymentGenerator.compile(
             this.bytecode,
             this.randomBytes,
-            this.preimage,
+            this.challenge,
             this.priorityFee,
             this.calldata,
             this.generateFeatures(parameters),
@@ -195,7 +195,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
      * @returns {Buffer} The contract bytecode
      */
     public getPreimage(): ChallengeSolution {
-        return this.preimage;
+        return this.challenge;
     }
 
     public getContractAddress(): string {