@btc-vision/transaction 1.5.4 → 1.6.1

package/src/epoch/validator/EpochValidator.ts

@@ -0,0 +1,180 @@
+import { IChallengeSolution, RawChallenge } from '../interfaces/IChallengeSolution.js';
+import { ChallengeSolution } from '../ChallengeSolution.js';
+
+export class EpochValidator {
+    private static readonly BLOCKS_PER_EPOCH: bigint = 5n;
+    private static readonly GRAFFITI_LENGTH: number = 16;
+
+    /**
+     * Convert Buffer to Uint8Array
+     */
+    public static bufferToUint8Array(buffer: Buffer): Uint8Array {
+        return new Uint8Array(buffer);
+    }
+
+    /**
+     * Convert Uint8Array to Buffer
+     */
+    public static uint8ArrayToBuffer(array: Uint8Array): Buffer {
+        return Buffer.from(array);
+    }
+
+    /**
+     * 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);
+    }
+
+    /**
+     * Calculate mining preimage
+     */
+    public static calculatePreimage(checksumRoot: Buffer, publicKey: Buffer, salt: Buffer): Buffer {
+        // Ensure all are 32 bytes
+        if (checksumRoot.length !== 32 || publicKey.length !== 32 || salt.length !== 32) {
+            throw new Error('All inputs must be 32 bytes');
+        }
+
+        const preimage = Buffer.alloc(32);
+        for (let i = 0; i < 32; i++) {
+            preimage[i] = checksumRoot[i] ^ publicKey[i] ^ salt[i];
+        }
+
+        return preimage;
+    }
+
+    /**
+     * Count matching bits between two hashes
+     */
+    public static countMatchingBits(hash1: Buffer, hash2: Buffer): number {
+        let matchingBits = 0;
+        if (hash1.length !== hash2.length) {
+            throw new Error('Hashes must be of the same length');
+        }
+
+        const minLength = Math.min(hash1.length, hash2.length);
+        for (let i = 0; i < minLength; i++) {
+            const byte1 = hash1[i];
+            const byte2 = hash2[i];
+
+            if (byte1 === byte2) {
+                matchingBits += 8;
+            } else {
+                // Check individual bits
+                for (let bit = 7; bit >= 0; bit--) {
+                    if (((byte1 >> bit) & 1) === ((byte2 >> bit) & 1)) {
+                        matchingBits++;
+                    } else {
+                        return matchingBits;
+                    }
+                }
+            }
+        }
+
+        return matchingBits;
+    }
+
+    /**
+     * Verify an epoch solution using IPreimage
+     */
+    public static async verifySolution(
+        challenge: IChallengeSolution,
+        log: boolean = false,
+    ): Promise<boolean> {
+        try {
+            const verification = challenge.verification;
+            const calculatedPreimage = this.calculatePreimage(
+                verification.targetChecksum,
+                challenge.publicKey.toBuffer(),
+                challenge.salt,
+            );
+
+            const computedSolution = await this.sha1(this.bufferToUint8Array(calculatedPreimage));
+            const computedSolutionBuffer = this.uint8ArrayToBuffer(computedSolution);
+
+            if (!computedSolutionBuffer.equals(challenge.solution)) {
+                return false;
+            }
+
+            const matchingBits = this.countMatchingBits(
+                computedSolutionBuffer,
+                verification.targetHash,
+            );
+
+            if (matchingBits !== challenge.difficulty) {
+                return false;
+            }
+
+            const expectedStartBlock = challenge.epochNumber * this.BLOCKS_PER_EPOCH;
+            const expectedEndBlock = expectedStartBlock + this.BLOCKS_PER_EPOCH - 1n;
+
+            return !(
+                verification.startBlock !== expectedStartBlock ||
+                verification.endBlock !== expectedEndBlock
+            );
+        } catch (error) {
+            if (log) console.error('Verification error:', error);
+            return false;
+        }
+    }
+
+    /**
+     * Get the mining target block for an epoch
+     */
+    public static getMiningTargetBlock(epochNumber: bigint): bigint | null {
+        if (epochNumber === 0n) {
+            return null; // Epoch 0 cannot be mined
+        }
+
+        // Last block of previous epoch
+        return epochNumber * this.BLOCKS_PER_EPOCH - 1n;
+    }
+
+    /**
+     * Validate epoch winner from raw data
+     */
+    public static async validateEpochWinner(epochData: RawChallenge): Promise<boolean> {
+        const preimage = new ChallengeSolution(epochData);
+        return await this.verifySolution(preimage);
+    }
+
+    /**
+     * Validate epoch winner from Preimage instance
+     */
+    public static async validateChallengeSolution(challenge: IChallengeSolution): Promise<boolean> {
+        return await this.verifySolution(challenge);
+    }
+
+    /**
+     * Calculate solution hash from preimage components
+     * @param targetChecksum The target checksum (32 bytes)
+     * @param publicKey The public key buffer (32 bytes)
+     * @param salt The salt buffer (32 bytes)
+     * @returns The SHA-1 hash of the preimage
+     */
+    public static async calculateSolution(
+        targetChecksum: Buffer,
+        publicKey: Buffer,
+        salt: Buffer,
+    ): Promise<Buffer> {
+        const preimage = this.calculatePreimage(targetChecksum, publicKey, salt);
+        const hash = await this.sha1(this.bufferToUint8Array(preimage));
+        return this.uint8ArrayToBuffer(hash);
+    }
+
+    /**
+     * Check if a solution meets the minimum difficulty requirement
+     */
+    public static checkDifficulty(
+        solution: Buffer,
+        targetHash: Buffer,
+        minDifficulty: number,
+    ): { valid: boolean; difficulty: number } {
+        const difficulty = this.countMatchingBits(solution, targetHash);
+        return {
+            valid: difficulty >= minDifficulty,
+            difficulty,
+        };
+    }
+}

package/src/generators/Features.ts

@@ -1,7 +1,9 @@
 import { LoadedStorage } from '../transaction/interfaces/ITransactionParameters.js';
+import { ChallengeSubmission } from '../epoch/ChallengeSolution.js';
 
 export enum Features {
     ACCESS_LIST = 1,
+    EPOCH_SUBMISSION = 2,
 }
 
 export interface Feature<T extends Features> {
@@ -12,3 +14,7 @@ export interface Feature<T extends Features> {
 export interface AccessListFeature extends Feature<Features.ACCESS_LIST> {
     data: LoadedStorage;
 }
+
+export interface EpochSubmissionFeature extends Feature<Features.EPOCH_SUBMISSION> {
+    data: ChallengeSubmission;
+}

package/src/generators/Generator.ts

@@ -1,6 +1,6 @@
 import { Network, networks, toXOnly } from '@btc-vision/bitcoin';
 import { BinaryWriter } from '../buffer/BinaryWriter.js';
-import { AccessListFeature, Feature, Features } from './Features.js';
+import { AccessListFeature, EpochSubmissionFeature, Feature, Features } from './Features.js';
 import { Address } from '../keypair/Address.js';
 import { Compressor } from '../bytecode/Compressor.js';
 
@@ -107,10 +107,16 @@ export abstract class Generator {
 
     protected encodeFeature(feature: Feature<Features>): Buffer[][] {
         switch (feature.opcode) {
-            case Features.ACCESS_LIST:
+            case Features.ACCESS_LIST: {
                 return this.splitBufferIntoChunks(
                     this.encodeAccessListFeature(feature as AccessListFeature),
                 );
+            }
+            case Features.EPOCH_SUBMISSION: {
+                return this.splitBufferIntoChunks(
+                    this.encodeChallengeSubmission(feature as EpochSubmissionFeature),
+                );
+            }
             default:
                 throw new Error(`Unknown feature type: ${feature.opcode}`);
         }
@@ -141,4 +147,20 @@ export abstract class Generator {
 
         return Compressor.compress(Buffer.from(writer.getBuffer()));
     }
+
+    private encodeChallengeSubmission(feature: EpochSubmissionFeature): Buffer {
+        if ('verifySignature' in feature.data && !feature.data.verifySignature()) {
+            throw new Error('Invalid signature in challenge submission feature');
+        }
+
+        const writer = new BinaryWriter();
+        writer.writeBytes(feature.data.publicKey.originalPublicKeyBuffer());
+        writer.writeBytes(feature.data.solution);
+
+        if (feature.data.graffiti) {
+            writer.writeBytesWithLength(feature.data.graffiti);
+        }
+
+        return Buffer.from(writer.getBuffer());
+    }
 }

package/src/generators/builders/CalldataGenerator.ts

@@ -4,6 +4,7 @@ import { Compressor } from '../../bytecode/Compressor.js';
 import { EcKeyPair } from '../../keypair/EcKeyPair.js';
 import { Feature, Features } from '../Features.js';
 import { Generator } from '../Generator.js';
+import { ChallengeSolution } from '../../epoch/ChallengeSolution.js';
 
 /**
  * Class to generate bitcoin script for interaction transactions
@@ -56,7 +57,7 @@ export class CalldataGenerator extends Generator {
      * Compile an interaction bitcoin script
      * @param {Buffer} calldata - The calldata to use
      * @param {Buffer} contractSecret - The contract secret
-     * @param preimage
+     * @param {ChallengeSolution} challenge
      * @param maxPriority - Amount of satoshis to spend max on priority fee
      * @param {Feature<Features>[]} features - The features to use
      * @returns {Buffer} - The compiled script
@@ -65,7 +66,7 @@ export class CalldataGenerator extends Generator {
     public compile(
         calldata: Buffer,
         contractSecret: Buffer,
-        preimage: Buffer,
+        challenge: ChallengeSolution,
         maxPriority: bigint,
         features: Feature<Features>[] = [],
     ): Buffer {
@@ -89,7 +90,10 @@ export class CalldataGenerator extends Generator {
             opcodes.OP_TOALTSTACK,
 
             // CHALLENGE PREIMAGE FOR REWARD,
-            preimage,
+            challenge.publicKey.originalPublicKeyBuffer(),
+            opcodes.OP_TOALTSTACK,
+
+            challenge.solution,
             opcodes.OP_TOALTSTACK,
 
             this.xSenderPubKey,

package/src/generators/builders/DeploymentGenerator.ts

@@ -1,6 +1,7 @@
 import { crypto, Network, networks, opcodes, script } from '@btc-vision/bitcoin';
 import { Generator } from '../Generator.js';
 import { Feature, Features } from '../Features.js';
+import { ChallengeSolution } from '../../epoch/ChallengeSolution.js';
 
 export const OPNET_DEPLOYMENT_VERSION = 0x00;
 export const versionBuffer = Buffer.from([OPNET_DEPLOYMENT_VERSION]);
@@ -18,19 +19,28 @@ 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 {Buffer} 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
      * @returns {Buffer} - The compiled script
      */
     public compile(
         contractBytecode: Buffer,
         contractSalt: Buffer,
-        preimage: Buffer,
+        challenge: ChallengeSolution,
         maxPriority: bigint,
         calldata?: Buffer,
+        features?: Feature<Features>[],
     ): Buffer {
-        const asm = this.getAsm(contractBytecode, contractSalt, preimage, maxPriority, calldata);
+        const asm = this.getAsm(
+            contractBytecode,
+            contractSalt,
+            challenge,
+            maxPriority,
+            calldata,
+            features,
+        );
         const compiled = script.compile(asm);
 
         /**
@@ -47,7 +57,7 @@ export class DeploymentGenerator extends Generator {
     private getAsm(
         contractBytecode: Buffer,
         contractSalt: Buffer,
-        preimage: Buffer,
+        challenge: ChallengeSolution,
         maxPriority: bigint,
         calldata?: Buffer,
         features?: Feature<Features>[],
@@ -55,7 +65,6 @@ export class DeploymentGenerator extends Generator {
         if (!this.contractSaltPubKey) throw new Error('Contract salt public key not set');
 
         const dataChunks: Buffer[][] = this.splitBufferIntoChunks(contractBytecode);
-
         const calldataChunks: Buffer[][] = calldata ? this.splitBufferIntoChunks(calldata) : [];
 
         const featuresList: Features[] = [];
@@ -76,7 +85,10 @@ export class DeploymentGenerator extends Generator {
             opcodes.OP_TOALTSTACK,
 
             // CHALLENGE PREIMAGE FOR REWARD,
-            preimage,
+            challenge.publicKey.originalPublicKeyBuffer(),
+            opcodes.OP_TOALTSTACK,
+
+            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/Address.ts

@@ -5,6 +5,7 @@ import { AddressVerificator } from './AddressVerificator.js';
 import { EcKeyPair } from './EcKeyPair.js';
 import { ContractAddress } from '../transaction/ContractAddress.js';
 import { BitcoinUtils } from '../utils/BitcoinUtils.js';
+import { ITimeLockOutput, TimeLockGenerator } from '../transaction/mineable/TimelockGenerator.js';
 
 /**
  * Objects of type "Address" are the representation of tweaked public keys. They can be converted to different address formats.
@@ -317,6 +318,39 @@ export class Address extends Uint8Array {
         throw new Error('Public key not set');
     }
 
+    /**
+     * Generate a P2WSH address with CSV (CheckSequenceVerify) timelock
+     * The resulting address can only be spent after the specified number of blocks
+     * have passed since the UTXO was created.
+     *
+     * @param {bigint | number | string} duration - The number of blocks that must pass before spending (1-65535)
+     * @param {Network} network - The Bitcoin network to use
+     * @returns {ITimeLockOutput} The timelocked address and its witness script
+     * @throws {Error} If the block number is out of range or public key is not available
+     */
+    public toCSV(duration: bigint | number | string, network: Network): ITimeLockOutput {
+        const n = Number(duration);
+
+        // First, let's validate the block number to ensure it's within the valid range
+        // CSV uses sequence numbers, which have special encoding for block-based locks
+        if (n < 1 || n > 65535) {
+            throw new Error('CSV block number must be between 1 and 65535');
+        }
+
+        // We need the original public key in compressed format for the script
+        // Your class stores this in #originalPublicKey when a key is set
+        if (!this.#originalPublicKey) {
+            throw new Error('Cannot create CSV address: public key not set');
+        }
+
+        // Convert the public key to Buffer format that TimeLockGenerator expects
+        const publicKeyBuffer = Buffer.from(this.#originalPublicKey);
+
+        // Now we can use your TimeLockGenerator to create the timelocked address
+        // Converting bigint to number is safe here because we've already validated the range
+        return TimeLockGenerator.generateTimeLockAddress(publicKeyBuffer, network, n);
+    }
+
     /**
      * Get an opnet address encoded in bech32m format.
      * @param network

package/src/keypair/EcKeyPair.ts

@@ -26,9 +26,8 @@ if (!BIP32factory) {
     throw new Error('Failed to load BIP32 library');
 }
 
-secp256k1.utils.precompute(8);
-
-const { Point, CURVE } = secp256k1;
+const Point = secp256k1.Point;
+const CURVE_N = Point.Fn.ORDER;
 
 const TAP_TAG = utf8ToBytes('TapTweak');
 const TAP_TAG_HASH = sha256(TAP_TAG);
@@ -48,6 +47,12 @@ export class EcKeyPair {
     public static BIP32: BIP32API = BIP32factory(ecc);
     public static ECPair: ECPairAPI = ECPairFactory(ecc);
 
+    // Initialize precomputation for better performance
+    static {
+        // Precompute tables for the base point for better performance
+        Point.BASE.precompute(8);
+    }
+
     /**
      * Generate a keypair from a WIF
      * @param {string} wif - The WIF to use
@@ -274,7 +279,7 @@ export class EcKeyPair {
 
         const xBytes = Peven.toBytes(true).subarray(1);
         const tBytes = tapTweakHash(xBytes);
-        const t = mod(bytesToNumberBE(tBytes), CURVE.n);
+        const t = mod(bytesToNumberBE(tBytes), CURVE_N);
 
         const Q = Peven.add(Point.BASE.multiply(t));
         return Buffer.from(Q.toBytes(true));

package/src/opnet.ts

@@ -10,12 +10,11 @@ export * from './generators/builders/CalldataGenerator.js';
 export * from './generators/builders/CustomGenerator.js';
 export * from './generators/builders/DeploymentGenerator.js';
 export * from './generators/builders/LegacyCalldataGenerator.js';
-export * from './generators/builders/MineableReward.js';
 export * from './generators/builders/MultiSignGenerator.js';
 export * from './generators/Features.js';
 export * from './generators/Generator.js';
 
-export * from './transaction/mineable/ChallengeGenerator.js';
+export * from './transaction/mineable/TimelockGenerator.js';
 
 /** Address */
 export * from './generators/AddressGenerator.js';
@@ -42,7 +41,6 @@ export * from './transaction/interfaces/Tap.js';
 export * from './transaction/TransactionFactory.js';
 
 /** Builders */
-export * from './transaction/builders/ChallengeSolutionTransaction.js';
 export * from './transaction/builders/CustomScriptTransaction.js';
 export * from './transaction/builders/DeploymentTransaction.js';
 export * from './transaction/builders/FundingTransaction.js';
@@ -51,6 +49,11 @@ export * from './transaction/builders/MultiSignTransaction.js';
 export * from './transaction/builders/SharedInteractionTransaction.js';
 export * from './transaction/builders/TransactionBuilder.js';
 
+/** Epoch */
+export * from './epoch/interfaces/IChallengeSolution.js';
+export * from './epoch/validator/EpochValidator.js';
+export * from './epoch/ChallengeSolution.js';
+
 /** Utils */
 export * from './utils/BitcoinUtils.js';
 export * from './utils/lengths.js';

package/src/transaction/TransactionFactory.ts

@@ -11,26 +11,25 @@ import { InteractionTransaction } from './builders/InteractionTransaction.js';
 import { TransactionBuilder } from './builders/TransactionBuilder.js';
 import { TransactionType } from './enums/TransactionType.js';
 import {
-    IChallengeSolutionTransactionParameters,
     IDeploymentParameters,
     IFundingTransactionParameters,
     IInteractionParameters,
     ITransactionParameters,
 } from './interfaces/ITransactionParameters.js';
 import { PSBTTypes } from './psbt/PSBTTypes.js';
-import { ChallengeSolutionTransaction } from './builders/ChallengeSolutionTransaction.js';
 import {
     IDeploymentParametersWithoutSigner,
     InteractionParametersWithoutSigner,
 } from './browser/Web3Provider.js';
 import { WindowWithWallets } from './browser/extensions/UnisatSigner.js';
+import { RawChallenge } from '../epoch/interfaces/IChallengeSolution.js';
 
 export interface DeploymentResult {
     readonly transaction: [string, string];
 
     readonly contractAddress: string;
     readonly contractPubKey: string;
-    readonly preimage: string;
+    readonly challenge: RawChallenge;
 
     readonly utxos: UTXO[];
 }
@@ -42,13 +41,6 @@ export interface FundingTransactionResponse {
     readonly nextUTXOs: UTXO[];
 }
 
-export interface ChallengeSolutionResponse {
-    readonly tx: Transaction;
-    readonly original: ChallengeSolutionTransaction;
-    readonly estimatedFees: bigint;
-    readonly nextUTXOs: UTXO[];
-}
-
 export interface BitcoinTransferBase {
     readonly tx: string;
     readonly estimatedFees: bigint;
@@ -60,11 +52,7 @@ export interface InteractionResponse {
     readonly interactionTransaction: string;
     readonly estimatedFees: bigint;
     readonly nextUTXOs: UTXO[];
-    readonly preimage: string;
-}
-
-export interface ChallengeSolution extends BitcoinTransferBase {
-    readonly original: ChallengeSolutionTransaction;
+    readonly challenge: RawChallenge;
 }
 
 export interface BitcoinTransferResponse extends BitcoinTransferBase {
@@ -246,7 +234,7 @@ export class TransactionFactory {
                 ...this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.to, 0),
             ], // always 0
             randomBytes: preTransaction.getRndBytes(),
-            preimage: preTransaction.getPreimage(),
+            challenge: preTransaction.getPreimage(),
             nonWitnessUtxo: signedTransaction.tx.toBuffer(),
             estimatedFees: preTransaction.estimatedFees,
             optionalInputs: inputs,
@@ -265,7 +253,7 @@ export class TransactionFactory {
                 interactionParameters.from,
                 1,
             ), // always 1
-            preimage: preTransaction.getPreimage().toString('hex'),
+            challenge: preTransaction.getPreimage().toRaw(),
         };
     }
 
@@ -343,7 +331,7 @@ export class TransactionFactory {
             ...deploymentParameters,
             utxos: [newUtxo], // always 0
             randomBytes: preTransaction.getRndBytes(),
-            preimage: preTransaction.getPreimage(),
+            challenge: preTransaction.getPreimage(),
             nonWitnessUtxo: signedTransaction.toBuffer(),
             estimatedFees: preTransaction.estimatedFees,
             optionalInputs: inputs,
@@ -370,7 +358,7 @@ export class TransactionFactory {
             contractAddress: finalTransaction.getContractAddress(), //finalTransaction.contractAddress.p2tr(deploymentParameters.network),
             contractPubKey: finalTransaction.contractPubKey,
             utxos: [refundUTXO],
-            preimage: preTransaction.getPreimage().toString('hex'),
+            challenge: preTransaction.getPreimage().toRaw(),
         };
     }
 
@@ -395,27 +383,6 @@ export class TransactionFactory {
         };
     }
 
-    /**
-     * @description Creates a challenge solution transaction.
-     * @param {IChallengeSolutionTransactionParameters} parameters - The challenge solution transaction parameters
-     * @returns {Promise<ChallengeSolution>} - The signed transaction
-     */
-    public async createChallengeSolution(
-        parameters: IChallengeSolutionTransactionParameters,
-    ): Promise<ChallengeSolution> {
-        if (!parameters.from) {
-            throw new Error('Field "from" not provided.');
-        }
-
-        const resp = await this._createChallengeSolution(parameters);
-        return {
-            estimatedFees: resp.estimatedFees,
-            original: resp.original,
-            tx: resp.tx.toHex(),
-            nextUTXOs: this.getAllNewUTXOs(resp.original, resp.tx, parameters.from),
-        };
-    }
-
     /**
      * Get all new UTXOs of a generated transaction.
      * @param {TransactionBuilder<TransactionType>} original - The original transaction
@@ -520,28 +487,6 @@ export class TransactionFactory {
         return deployment;
     }
 
-    private async _createChallengeSolution(
-        parameters: IChallengeSolutionTransactionParameters,
-    ): Promise<ChallengeSolutionResponse> {
-        if (!parameters.to) throw new Error('Field "to" not provided.');
-
-        const challengeTransaction: ChallengeSolutionTransaction = new ChallengeSolutionTransaction(
-            parameters,
-        );
-
-        const signedTransaction: Transaction = await challengeTransaction.signTransaction();
-        if (!signedTransaction) {
-            throw new Error('Could not sign funding transaction.');
-        }
-
-        return {
-            tx: signedTransaction,
-            original: challengeTransaction,
-            estimatedFees: challengeTransaction.estimatedFees,
-            nextUTXOs: this.getUTXOAsTransaction(signedTransaction, parameters.to, 0),
-        };
-    }
-
     private async createFundTransaction(
         parameters: IFundingTransactionParameters,
     ): Promise<FundingTransactionResponse> {

package/src/transaction/browser/Web3Provider.ts

@@ -8,17 +8,17 @@ import { ICustomTransactionParameters } from '../builders/CustomScriptTransactio
 
 export type InteractionParametersWithoutSigner = Omit<
     IInteractionParameters,
-    'signer' | 'preimage'
+    'signer' | 'challenge'
 >;
 
 export type IDeploymentParametersWithoutSigner = Omit<
     IDeploymentParameters,
-    'signer' | 'network' | 'preimage'
+    'signer' | 'network' | 'challenge'
 >;
 
 export type CustomTransactionWithoutSigner = Omit<
     ICustomTransactionParameters,
-    'signer' | 'preimage'
+    'signer' | 'challenge'
 >;
 
 export interface BroadcastTransactionOptions {