@btc-vision/transaction 1.5.3 → 1.6.0

package/build/epoch/validator/EpochValidator.js

@@ -0,0 +1,99 @@
+import { ChallengeSolution } from '../ChallengeSolution.js';
+export class EpochValidator {
+    static bufferToUint8Array(buffer) {
+        return new Uint8Array(buffer);
+    }
+    static uint8ArrayToBuffer(array) {
+        return Buffer.from(array);
+    }
+    static async sha1(data) {
+        const hashBuffer = await crypto.subtle.digest('SHA-1', data);
+        return new Uint8Array(hashBuffer);
+    }
+    static calculatePreimage(checksumRoot, publicKey, salt) {
+        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;
+    }
+    static countMatchingBits(hash1, hash2) {
+        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 {
+                for (let bit = 7; bit >= 0; bit--) {
+                    if (((byte1 >> bit) & 1) === ((byte2 >> bit) & 1)) {
+                        matchingBits++;
+                    }
+                    else {
+                        return matchingBits;
+                    }
+                }
+            }
+        }
+        return matchingBits;
+    }
+    static async verifySolution(preimage, log = false) {
+        try {
+            const verification = preimage.verification;
+            const calculatedPreimage = this.calculatePreimage(verification.targetChecksum, preimage.publicKey.toBuffer(), preimage.salt);
+            const computedSolution = await this.sha1(this.bufferToUint8Array(calculatedPreimage));
+            const computedSolutionBuffer = this.uint8ArrayToBuffer(computedSolution);
+            if (!computedSolutionBuffer.equals(preimage.solution)) {
+                return false;
+            }
+            const matchingBits = this.countMatchingBits(computedSolutionBuffer, verification.targetHash);
+            if (matchingBits !== preimage.difficulty) {
+                return false;
+            }
+            const expectedStartBlock = preimage.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;
+        }
+    }
+    static getMiningTargetBlock(epochNumber) {
+        if (epochNumber === 0n) {
+            return null;
+        }
+        return epochNumber * this.BLOCKS_PER_EPOCH - 1n;
+    }
+    static async validateEpochWinner(epochData) {
+        const preimage = new ChallengeSolution(epochData);
+        return await this.verifySolution(preimage);
+    }
+    static async validatePreimage(preimage) {
+        return await this.verifySolution(preimage);
+    }
+    static async calculateSolution(targetChecksum, publicKey, salt) {
+        const preimage = this.calculatePreimage(targetChecksum, publicKey, salt);
+        const hash = await this.sha1(this.bufferToUint8Array(preimage));
+        return this.uint8ArrayToBuffer(hash);
+    }
+    static checkDifficulty(solution, targetHash, minDifficulty) {
+        const difficulty = this.countMatchingBits(solution, targetHash);
+        return {
+            valid: difficulty >= minDifficulty,
+            difficulty,
+        };
+    }
+}
+EpochValidator.BLOCKS_PER_EPOCH = 5n;
+EpochValidator.GRAFFITI_LENGTH = 16;

package/build/generators/Features.d.ts

@@ -1,6 +1,8 @@
 import { LoadedStorage } from '../transaction/interfaces/ITransactionParameters.js';
+import { ChallengeSubmission } from '../epoch/ChallengeSolution.js';
 export declare enum Features {
-    ACCESS_LIST = 1
+    ACCESS_LIST = 1,
+    EPOCH_SUBMISSION = 2
 }
 export interface Feature<T extends Features> {
     opcode: T;
@@ -9,3 +11,6 @@ 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/build/generators/Features.js

@@ -1,4 +1,5 @@
 export var Features;
 (function (Features) {
     Features[Features["ACCESS_LIST"] = 1] = "ACCESS_LIST";
+    Features[Features["EPOCH_SUBMISSION"] = 2] = "EPOCH_SUBMISSION";
 })(Features || (Features = {}));

package/build/generators/Generator.d.ts

@@ -14,4 +14,5 @@ export declare abstract class Generator {
     protected splitBufferIntoChunks(buffer: Buffer, chunkSize?: number): Array<Buffer[]>;
     protected encodeFeature(feature: Feature<Features>): Buffer[][];
     private encodeAccessListFeature;
+    private encodeChallengeSubmission;
 }

package/build/generators/Generator.js

@@ -40,8 +40,12 @@ export class Generator {
     }
     encodeFeature(feature) {
         switch (feature.opcode) {
-            case Features.ACCESS_LIST:
+            case Features.ACCESS_LIST: {
                 return this.splitBufferIntoChunks(this.encodeAccessListFeature(feature));
+            }
+            case Features.EPOCH_SUBMISSION: {
+                return this.splitBufferIntoChunks(this.encodeChallengeSubmission(feature));
+            }
             default:
                 throw new Error(`Unknown feature type: ${feature.opcode}`);
         }
@@ -64,6 +68,18 @@ export class Generator {
         }
         return Compressor.compress(Buffer.from(writer.getBuffer()));
     }
+    encodeChallengeSubmission(feature) {
+        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());
+    }
 }
 Generator.DATA_CHUNK_SIZE = 512;
 Generator.MAGIC = Buffer.from('op', 'utf-8');

package/build/generators/builders/CalldataGenerator.d.ts

@@ -1,8 +1,9 @@
 import { Network } from '@btc-vision/bitcoin';
 import { Feature, Features } from '../Features.js';
 import { Generator } from '../Generator.js';
+import { ChallengeSolution } from '../../epoch/ChallengeSolution.js';
 export declare class CalldataGenerator extends Generator {
     constructor(senderPubKey: Buffer, contractSaltPubKey: Buffer, network?: Network);
     static getPubKeyAsBuffer(witnessKeys: Buffer[], network: Network): Buffer;
-    compile(calldata: Buffer, contractSecret: Buffer, preimage: Buffer, maxPriority: bigint, features?: Feature<Features>[]): Buffer;
+    compile(calldata: Buffer, contractSecret: Buffer, challenge: ChallengeSolution, maxPriority: bigint, features?: Feature<Features>[]): Buffer;
 }

package/build/generators/builders/CalldataGenerator.js

@@ -24,7 +24,7 @@ export class CalldataGenerator extends Generator {
         }
         return compressed;
     }
-    compile(calldata, contractSecret, preimage, maxPriority, features = []) {
+    compile(calldata, contractSecret, challenge, maxPriority, features = []) {
         if (!this.contractSaltPubKey)
             throw new Error('Contract salt public key not set');
         const dataChunks = this.splitBufferIntoChunks(calldata);
@@ -41,7 +41,9 @@ export class CalldataGenerator extends Generator {
         let compiledData = [
             this.getHeader(maxPriority, featuresList),
             opcodes.OP_TOALTSTACK,
-            preimage,
+            challenge.publicKey.originalPublicKeyBuffer(),
+            opcodes.OP_TOALTSTACK,
+            challenge.solution,
             opcodes.OP_TOALTSTACK,
             this.xSenderPubKey,
             opcodes.OP_DUP,

package/build/generators/builders/DeploymentGenerator.d.ts

@@ -1,9 +1,11 @@
 import { Network } from '@btc-vision/bitcoin';
 import { Generator } from '../Generator.js';
+import { Feature, Features } from '../Features.js';
+import { ChallengeSolution } from '../../epoch/ChallengeSolution.js';
 export declare const OPNET_DEPLOYMENT_VERSION = 0;
 export declare const versionBuffer: Buffer<ArrayBuffer>;
 export declare class DeploymentGenerator extends Generator {
     constructor(senderPubKey: Buffer, contractSaltPubKey: Buffer, network?: Network);
-    compile(contractBytecode: Buffer, contractSalt: Buffer, preimage: Buffer, maxPriority: bigint, calldata?: Buffer): Buffer;
+    compile(contractBytecode: Buffer, contractSalt: Buffer, preimage: ChallengeSolution, maxPriority: bigint, calldata?: Buffer, features?: Feature<Features>[]): Buffer;
     private getAsm;
 }

package/build/generators/builders/DeploymentGenerator.js

@@ -6,8 +6,8 @@ export class DeploymentGenerator extends Generator {
     constructor(senderPubKey, contractSaltPubKey, network = networks.bitcoin) {
         super(senderPubKey, contractSaltPubKey, network);
     }
-    compile(contractBytecode, contractSalt, preimage, maxPriority, calldata) {
-        const asm = this.getAsm(contractBytecode, contractSalt, preimage, maxPriority, calldata);
+    compile(contractBytecode, contractSalt, preimage, maxPriority, calldata, features) {
+        const asm = this.getAsm(contractBytecode, contractSalt, preimage, maxPriority, calldata, features);
         const compiled = script.compile(asm);
         const decompiled = script.decompile(compiled);
         if (!decompiled) {
@@ -33,7 +33,9 @@ export class DeploymentGenerator extends Generator {
         const compiledData = [
             this.getHeader(maxPriority, featuresList),
             opcodes.OP_TOALTSTACK,
-            preimage,
+            preimage.publicKey.originalPublicKeyBuffer(),
+            opcodes.OP_TOALTSTACK,
+            preimage.solution,
             opcodes.OP_TOALTSTACK,
             this.xSenderPubKey,
             opcodes.OP_DUP,

package/build/keypair/Address.d.ts

@@ -1,4 +1,5 @@
 import { Network } from '@btc-vision/bitcoin';
+import { ITimeLockOutput } from '../transaction/mineable/TimelockGenerator.js';
 export declare class Address extends Uint8Array {
     #private;
     constructor(bytes?: ArrayLike<number>);
@@ -28,6 +29,7 @@ export declare class Address extends Uint8Array {
     toString(): string;
     toJSON(): string;
     p2tr(network: Network): string;
+    toCSV(duration: bigint | number | string, network: Network): ITimeLockOutput;
     p2op(network: Network): string;
     toTweakedHybridPublicKeyHex(): string;
     toTweakedHybridPublicKeyBuffer(): Buffer;

package/build/keypair/Address.js

@@ -16,6 +16,7 @@ import { AddressVerificator } from './AddressVerificator.js';
 import { EcKeyPair } from './EcKeyPair.js';
 import { ContractAddress } from '../transaction/ContractAddress.js';
 import { BitcoinUtils } from '../utils/BitcoinUtils.js';
+import { TimeLockGenerator } from '../transaction/mineable/TimelockGenerator.js';
 export class Address extends Uint8Array {
     constructor(bytes) {
         super(ADDRESS_BYTE_LENGTH);
@@ -194,6 +195,17 @@ export class Address extends Uint8Array {
         }
         throw new Error('Public key not set');
     }
+    toCSV(duration, network) {
+        const n = Number(duration);
+        if (n < 1 || n > 65535) {
+            throw new Error('CSV block number must be between 1 and 65535');
+        }
+        if (!__classPrivateFieldGet(this, _Address_originalPublicKey, "f")) {
+            throw new Error('Cannot create CSV address: public key not set');
+        }
+        const publicKeyBuffer = Buffer.from(__classPrivateFieldGet(this, _Address_originalPublicKey, "f"));
+        return TimeLockGenerator.generateTimeLockAddress(publicKeyBuffer, network, n);
+    }
     p2op(network) {
         if (__classPrivateFieldGet(this, _Address_p2op, "f") && __classPrivateFieldGet(this, _Address_network, "f") === network) {
             return __classPrivateFieldGet(this, _Address_p2op, "f");

package/build/keypair/EcKeyPair.js

@@ -11,8 +11,8 @@ const BIP32factory = typeof bip32 === 'function' ? bip32 : BIP32Factory;
 if (!BIP32factory) {
     throw new Error('Failed to load BIP32 library');
 }
-secp256k1.utils.precompute(8);
-const { ProjectivePoint: 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);
 function tapTweakHash(x) {
@@ -113,19 +113,19 @@ export class EcKeyPair {
             pub = pub.slice(2);
         const P = Point.fromHex(pub);
         const Peven = (P.y & 1n) === 0n ? P : P.negate();
-        const xBytes = Peven.toRawBytes(true).subarray(1);
+        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.toRawBytes(true));
+        return Buffer.from(Q.toBytes(true));
     }
     static tweakBatchSharedT(pubkeys, tweakScalar) {
         const T = Point.BASE.multiply(tweakScalar);
         return pubkeys.map((bytes) => {
             const P = Point.fromHex(bytes);
-            const P_even = P.hasEvenY() ? P : P.negate();
+            const P_even = P.y % 2n === 0n ? P : P.negate();
             const Q = P_even.add(T);
-            return Q.toRawBytes(true);
+            return Q.toBytes(true);
         });
     }
     static generateWallet(network = networks.bitcoin) {
@@ -214,3 +214,6 @@ export class EcKeyPair {
 }
 EcKeyPair.BIP32 = BIP32factory(ecc);
 EcKeyPair.ECPair = ECPairFactory(ecc);
+(() => {
+    Point.BASE.precompute(8);
+})();

package/build/opnet.d.ts

@@ -5,11 +5,10 @@ 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';
 export * from './generators/AddressGenerator.js';
 export * from './verification/TapscriptVerificator.js';
 export * from './keypair/AddressVerificator.js';
@@ -24,7 +23,6 @@ export * from './transaction/enums/TransactionType.js';
 export * from './transaction/interfaces/ITransactionParameters.js';
 export * from './transaction/interfaces/Tap.js';
 export * from './transaction/TransactionFactory.js';
-export * from './transaction/builders/ChallengeSolutionTransaction.js';
 export * from './transaction/builders/CustomScriptTransaction.js';
 export * from './transaction/builders/DeploymentTransaction.js';
 export * from './transaction/builders/FundingTransaction.js';
@@ -32,6 +30,9 @@ export * from './transaction/builders/InteractionTransaction.js';
 export * from './transaction/builders/MultiSignTransaction.js';
 export * from './transaction/builders/SharedInteractionTransaction.js';
 export * from './transaction/builders/TransactionBuilder.js';
+export * from './epoch/interfaces/IChallengeSolution.js';
+export * from './epoch/validator/EpochValidator.js';
+export * from './epoch/ChallengeSolution.js';
 export * from './utils/BitcoinUtils.js';
 export * from './utils/lengths.js';
 export * from './utxo/interfaces/IUTXO.js';

package/build/opnet.js

@@ -4,11 +4,10 @@ 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';
 export * from './generators/AddressGenerator.js';
 export * from './verification/TapscriptVerificator.js';
 export * from './keypair/AddressVerificator.js';
@@ -23,7 +22,6 @@ export * from './transaction/enums/TransactionType.js';
 export * from './transaction/interfaces/ITransactionParameters.js';
 export * from './transaction/interfaces/Tap.js';
 export * from './transaction/TransactionFactory.js';
-export * from './transaction/builders/ChallengeSolutionTransaction.js';
 export * from './transaction/builders/CustomScriptTransaction.js';
 export * from './transaction/builders/DeploymentTransaction.js';
 export * from './transaction/builders/FundingTransaction.js';
@@ -31,6 +29,9 @@ export * from './transaction/builders/InteractionTransaction.js';
 export * from './transaction/builders/MultiSignTransaction.js';
 export * from './transaction/builders/SharedInteractionTransaction.js';
 export * from './transaction/builders/TransactionBuilder.js';
+export * from './epoch/interfaces/IChallengeSolution.js';
+export * from './epoch/validator/EpochValidator.js';
+export * from './epoch/ChallengeSolution.js';
 export * from './utils/BitcoinUtils.js';
 export * from './utils/lengths.js';
 export * from './utxo/interfaces/IUTXO.js';

package/build/transaction/TransactionFactory.d.ts

@@ -4,14 +4,14 @@ import { ICustomTransactionParameters } from './builders/CustomScriptTransaction
 import { FundingTransaction } from './builders/FundingTransaction.js';
 import { TransactionBuilder } from './builders/TransactionBuilder.js';
 import { TransactionType } from './enums/TransactionType.js';
-import { IChallengeSolutionTransactionParameters, IDeploymentParameters, IFundingTransactionParameters, IInteractionParameters } from './interfaces/ITransactionParameters.js';
-import { ChallengeSolutionTransaction } from './builders/ChallengeSolutionTransaction.js';
+import { IDeploymentParameters, IFundingTransactionParameters, IInteractionParameters } from './interfaces/ITransactionParameters.js';
 import { InteractionParametersWithoutSigner } from './browser/Web3Provider.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 preimage: RawChallenge;
     readonly utxos: UTXO[];
 }
 export interface FundingTransactionResponse {
@@ -20,12 +20,6 @@ export interface FundingTransactionResponse {
     readonly estimatedFees: bigint;
     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;
@@ -36,10 +30,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 preimage: RawChallenge;
 }
 export interface BitcoinTransferResponse extends BitcoinTransferBase {
     readonly original: FundingTransaction;
@@ -49,12 +40,10 @@ export declare class TransactionFactory {
     signInteraction(interactionParameters: IInteractionParameters | InteractionParametersWithoutSigner): Promise<InteractionResponse>;
     signDeployment(deploymentParameters: IDeploymentParameters): Promise<DeploymentResult>;
     createBTCTransfer(parameters: IFundingTransactionParameters): Promise<BitcoinTransferResponse>;
-    createChallengeSolution(parameters: IChallengeSolutionTransactionParameters): Promise<ChallengeSolution>;
     getAllNewUTXOs(original: TransactionBuilder<TransactionType>, tx: Transaction, to: string): UTXO[];
     private parseOptionalInputs;
     private detectInteractionOPWallet;
     private detectDeploymentOPWallet;
-    private _createChallengeSolution;
     private createFundTransaction;
     private writePSBTHeader;
     private getPriorityFee;

package/build/transaction/TransactionFactory.js

@@ -4,7 +4,6 @@ import { DeploymentTransaction } from './builders/DeploymentTransaction.js';
 import { FundingTransaction } from './builders/FundingTransaction.js';
 import { InteractionTransaction } from './builders/InteractionTransaction.js';
 import { TransactionBuilder } from './builders/TransactionBuilder.js';
-import { ChallengeSolutionTransaction } from './builders/ChallengeSolutionTransaction.js';
 export class TransactionFactory {
     async createCustomScriptTransaction(interactionParameters) {
         if (!interactionParameters.to) {
@@ -122,7 +121,7 @@ export class TransactionFactory {
                 ...this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.to, 0),
             ],
             randomBytes: preTransaction.getRndBytes(),
-            preimage: preTransaction.getPreimage(),
+            challenge: preTransaction.getPreimage(),
             nonWitnessUtxo: signedTransaction.tx.toBuffer(),
             estimatedFees: preTransaction.estimatedFees,
             optionalInputs: inputs,
@@ -134,7 +133,7 @@ export class TransactionFactory {
             interactionTransaction: outTx.toHex(),
             estimatedFees: preTransaction.estimatedFees,
             nextUTXOs: this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.from, 1),
-            preimage: preTransaction.getPreimage().toString('hex'),
+            preimage: preTransaction.getPreimage().toRaw(),
         };
     }
     async signDeployment(deploymentParameters) {
@@ -190,7 +189,7 @@ export class TransactionFactory {
             ...deploymentParameters,
             utxos: [newUtxo],
             randomBytes: preTransaction.getRndBytes(),
-            preimage: preTransaction.getPreimage(),
+            challenge: preTransaction.getPreimage(),
             nonWitnessUtxo: signedTransaction.toBuffer(),
             estimatedFees: preTransaction.estimatedFees,
             optionalInputs: inputs,
@@ -212,7 +211,7 @@ export class TransactionFactory {
             contractAddress: finalTransaction.getContractAddress(),
             contractPubKey: finalTransaction.contractPubKey,
             utxos: [refundUTXO],
-            preimage: preTransaction.getPreimage().toString('hex'),
+            preimage: preTransaction.getPreimage().toRaw(),
         };
     }
     async createBTCTransfer(parameters) {
@@ -227,18 +226,6 @@ export class TransactionFactory {
             nextUTXOs: this.getAllNewUTXOs(resp.original, resp.tx, parameters.from),
         };
     }
-    async createChallengeSolution(parameters) {
-        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),
-        };
-    }
     getAllNewUTXOs(original, tx, to) {
         const outputs = original.getOutputs();
         const utxos = [];
@@ -305,21 +292,6 @@ export class TransactionFactory {
         }
         return deployment;
     }
-    async _createChallengeSolution(parameters) {
-        if (!parameters.to)
-            throw new Error('Field "to" not provided.');
-        const challengeTransaction = new ChallengeSolutionTransaction(parameters);
-        const signedTransaction = 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),
-        };
-    }
     async createFundTransaction(parameters) {
         if (!parameters.to)
             throw new Error('Field "to" not provided.');

package/build/transaction/browser/Web3Provider.d.ts

@@ -2,9 +2,9 @@ import { IDeploymentParameters, IInteractionParameters } from '../interfaces/ITr
 import { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { DeploymentResult, InteractionResponse } from '../TransactionFactory';
 import { ICustomTransactionParameters } from '../builders/CustomScriptTransaction.js';
-export type InteractionParametersWithoutSigner = Omit<IInteractionParameters, 'signer' | 'preimage'>;
-export type IDeploymentParametersWithoutSigner = Omit<IDeploymentParameters, 'signer' | 'network' | 'preimage'>;
-export type CustomTransactionWithoutSigner = Omit<ICustomTransactionParameters, 'signer' | 'preimage'>;
+export type InteractionParametersWithoutSigner = Omit<IInteractionParameters, 'signer' | 'challenge'>;
+export type IDeploymentParametersWithoutSigner = Omit<IDeploymentParameters, 'signer' | 'network' | 'challenge'>;
+export type CustomTransactionWithoutSigner = Omit<ICustomTransactionParameters, 'signer' | 'challenge'>;
 export interface BroadcastTransactionOptions {
     raw: string;
     psbt: boolean;

package/build/transaction/browser/types/Unisat.d.ts

@@ -63,7 +63,7 @@ export interface Unisat {
     switchNetwork(network: UnisatNetwork): Promise<void>;
     getPublicKey(): Promise<string>;
     getBalance(): Promise<Balance>;
-    signMessage(message: string, type?: MessageType): Promise<string>;
+    signMessage(message: string | Buffer, type?: MessageType): Promise<string>;
     signData(hex: string, type?: SignatureType): Promise<string>;
     pushTx(options: {
         rawtx: string;

package/build/transaction/builders/ChallengeSolutionTransaction.d.ts

@@ -1,18 +0,0 @@
-import { TransactionType } from '../enums/TransactionType.js';
-import { IChallengeSolutionTransactionParameters } from '../interfaces/ITransactionParameters.js';
-import { Psbt, PsbtInput, Signer } from '@btc-vision/bitcoin';
-import { TransactionBuilder } from './TransactionBuilder.js';
-import { ECPairInterface } from 'ecpair';
-export declare class ChallengeSolutionTransaction extends TransactionBuilder<TransactionType.CHALLENGE_SOLUTION> {
-    readonly type: TransactionType.CHALLENGE_SOLUTION;
-    protected amount: bigint;
-    protected readonly challengeSolution: Buffer;
-    constructor(parameters: IChallengeSolutionTransactionParameters);
-    protected buildTransaction(): Promise<void>;
-    protected signInput(transaction: Psbt, input: PsbtInput, i: number, signer: Signer | ECPairInterface, reverse?: boolean, errored?: boolean): Promise<void>;
-    protected customFinalizerP2SH: (inputIndex: number, input: PsbtInput, scriptA: Buffer, isSegwit: boolean, isP2SH: boolean, isP2WSH: boolean) => {
-        finalScriptSig: Buffer | undefined;
-        finalScriptWitness: Buffer | undefined;
-    };
-    protected getSignerKey(): Signer | ECPairInterface;
-}

package/build/transaction/builders/ChallengeSolutionTransaction.js

@@ -1,51 +1 @@
-import { TransactionType } from '../enums/TransactionType.js';
-import { getFinalScripts, opcodes, script } from '@btc-vision/bitcoin';
-import { TransactionBuilder } from './TransactionBuilder.js';
-export class ChallengeSolutionTransaction extends TransactionBuilder {
-    constructor(parameters) {
-        super(parameters);
-        this.type = TransactionType.CHALLENGE_SOLUTION;
-        this.customFinalizerP2SH = (inputIndex, input, scriptA, isSegwit, isP2SH, isP2WSH) => {
-            const inputDecoded = this.inputs[inputIndex];
-            if (isP2SH && inputDecoded && inputDecoded.redeemScript) {
-                const scriptSig = script.compile([this.challengeSolution, inputDecoded.redeemScript]);
-                return {
-                    finalScriptSig: scriptSig,
-                    finalScriptWitness: undefined,
-                };
-            }
-            return getFinalScripts(inputIndex, input, scriptA, isSegwit, isP2SH, isP2WSH, false);
-        };
-        this.amount = parameters.amount;
-        this.challengeSolution = parameters.challengeSolution;
-        this.internalInit();
-    }
-    async buildTransaction() {
-        if (!this.to) {
-            throw new Error('Recipient address is required');
-        }
-        this.addInputsFromUTXO();
-        if (this.isPubKeyDestination) {
-            const pubKeyScript = script.compile([
-                Buffer.from(this.to.replace('0x', ''), 'hex'),
-                opcodes.OP_CHECKSIG,
-            ]);
-            this.addOutput({
-                value: Number(this.amount),
-                script: pubKeyScript,
-            });
-        }
-        else {
-            this.addOutput({
-                value: Number(this.amount),
-                address: this.to,
-            });
-        }
-        await this.addRefundOutput(this.amount + this.addOptionalOutputsAndGetAmount());
-    }
-    async signInput(transaction, input, i, signer, reverse = false, errored = false) {
-    }
-    getSignerKey() {
-        return this.signer;
-    }
-}
+"use strict";

package/build/transaction/builders/CustomScriptTransaction.d.ts

@@ -3,7 +3,7 @@ import { TransactionType } from '../enums/TransactionType.js';
 import { TapLeafScript } from '../interfaces/Tap.js';
 import { SharedInteractionParameters } from '../interfaces/ITransactionParameters.js';
 import { TransactionBuilder } from './TransactionBuilder.js';
-export interface ICustomTransactionParameters extends SharedInteractionParameters {
+export interface ICustomTransactionParameters extends Omit<SharedInteractionParameters, 'challenge'> {
     script: (Buffer | Stack)[];
     witnesses: Buffer[];
     annex?: Buffer;