@btc-vision/transaction 1.5.4 → 1.6.1

package/browser/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/browser/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/browser/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 challenge: 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 challenge: 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/browser/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/browser/transaction/builders/ChallengeSolutionTransaction.d.ts

@@ -1,18 +1 @@
-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;
-}
+export {};

package/browser/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;

package/browser/transaction/builders/DeploymentTransaction.d.ts

@@ -4,12 +4,13 @@ import { P2TRPayment, Psbt } from '@btc-vision/bitcoin';
 import { TransactionBuilder } from './TransactionBuilder.js';
 import { TapLeafScript } from '../interfaces/Tap.js';
 import { Address } from '../../keypair/Address.js';
-import { IMineableReward } from '../mineable/ChallengeGenerator.js';
+import { ITimeLockOutput } from '../mineable/TimelockGenerator.js';
+import { ChallengeSolution } from '../../epoch/ChallengeSolution.js';
 export declare class DeploymentTransaction extends TransactionBuilder<TransactionType.DEPLOYMENT> {
     static readonly MAXIMUM_CONTRACT_SIZE: number;
     type: TransactionType.DEPLOYMENT;
-    protected readonly preimage: Buffer;
-    protected readonly rewardChallenge: IMineableReward;
+    protected readonly challenge: ChallengeSolution;
+    protected readonly epochChallenge: ITimeLockOutput;
     protected readonly _contractAddress: Address;
     protected tapLeafScript: TapLeafScript | null;
     private readonly deploymentVersion;
@@ -30,7 +31,7 @@ export declare class DeploymentTransaction extends TransactionBuilder<Transactio
     get contractAddress(): Address;
     get p2trAddress(): string;
     getRndBytes(): Buffer;
-    getPreimage(): Buffer;
+    getPreimage(): ChallengeSolution;
     getContractAddress(): string;
     protected contractSignerXOnlyPubKey(): Buffer;
     protected buildTransaction(): Promise<void>;
@@ -38,6 +39,7 @@ export declare class DeploymentTransaction extends TransactionBuilder<Transactio
     protected signInputs(transaction: Psbt): Promise<void>;
     protected generateScriptAddress(): P2TRPayment;
     protected generateTapData(): P2TRPayment;
+    private generateFeatures;
     private verifyCalldata;
     private verifyBytecode;
     private getContractSeed;

package/browser/transaction/builders/SharedInteractionTransaction.d.ts

@@ -4,7 +4,8 @@ import { TransactionBuilder } from './TransactionBuilder.js';
 import { TransactionType } from '../enums/TransactionType.js';
 import { CalldataGenerator } from '../../generators/builders/CalldataGenerator.js';
 import { SharedInteractionParameters } from '../interfaces/ITransactionParameters.js';
-import { IMineableReward } from '../mineable/ChallengeGenerator.js';
+import { ITimeLockOutput } from '../mineable/TimelockGenerator.js';
+import { ChallengeSolution } from '../../epoch/ChallengeSolution.js';
 export declare abstract class SharedInteractionTransaction<T extends TransactionType> extends TransactionBuilder<T> {
     static readonly MAXIMUM_CALLDATA_SIZE: number;
     readonly randomBytes: Buffer;
@@ -12,8 +13,8 @@ export declare abstract class SharedInteractionTransaction<T extends Transaction
     protected leftOverFundsScriptRedeem: P2TRPayment | null;
     protected abstract readonly compiledTargetScript: Buffer;
     protected abstract readonly scriptTree: Taptree;
-    protected readonly preimage: Buffer;
-    protected readonly rewardChallenge: IMineableReward;
+    protected readonly challenge: ChallengeSolution;
+    protected readonly epochChallenge: ITimeLockOutput;
     protected calldataGenerator: CalldataGenerator;
     protected readonly calldata: Buffer;
     protected abstract readonly contractSecret: Buffer;
@@ -22,7 +23,7 @@ export declare abstract class SharedInteractionTransaction<T extends Transaction
     protected constructor(parameters: SharedInteractionParameters);
     getContractSecret(): Buffer;
     getRndBytes(): Buffer;
-    getPreimage(): Buffer;
+    getPreimage(): ChallengeSolution;
     protected scriptSignerXOnlyPubKey(): Buffer;
     protected generateKeyPairFromSeed(): ECPairInterface;
     protected buildTransaction(): Promise<void>;

package/browser/transaction/builders/TransactionBuilder.d.ts

@@ -33,9 +33,11 @@ export declare abstract class TransactionBuilder<T extends TransactionType> exte
     protected from: string;
     protected _maximumFeeRate: number;
     protected isPubKeyDestination: boolean;
+    protected note?: Buffer;
     protected constructor(parameters: ITransactionParameters);
     static getFrom(from: string | undefined, keypair: ECPairInterface | Signer, network: Network): string;
     static witnessStackToScriptWitness(witness: Buffer[]): Buffer;
+    addOPReturn(buffer: Buffer): void;
     getFundingTransactionParameters(): Promise<IFundingTransactionParameters>;
     setDestinationAddress(address: string): void;
     setMaximumFeeRate(feeRate: number): void;

package/browser/transaction/interfaces/ITransactionParameters.d.ts

@@ -2,6 +2,7 @@ import { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { ITweakedTransactionData } from '../shared/TweakedTransaction.js';
 import { ChainId } from '../../network/ChainId.js';
 import { PsbtOutputExtended } from '@btc-vision/bitcoin';
+import { ChallengeSolution } from '../../epoch/ChallengeSolution.js';
 export interface LoadedStorage {
     [key: string]: string[];
 }
@@ -15,6 +16,7 @@ export interface ITransactionParameters extends ITweakedTransactionData {
     optionalOutputs?: PsbtOutputExtended[];
     chainId?: ChainId;
     noSignatures?: boolean;
+    readonly note?: string | Buffer;
     readonly feeRate: number;
     readonly priorityFee: bigint;
     readonly gasSatFee: bigint;
@@ -23,14 +25,10 @@ export interface IFundingTransactionParameters extends ITransactionParameters {
     amount: bigint;
     splitInputsInto?: number;
 }
-export interface IChallengeSolutionTransactionParameters extends ITransactionParameters {
-    amount: bigint;
-    readonly challengeSolution: Buffer;
-}
 export interface SharedInteractionParameters extends ITransactionParameters {
     calldata?: Buffer;
     disableAutoRefund?: boolean;
-    readonly preimage: Buffer;
+    readonly challenge: ChallengeSolution;
     readonly randomBytes?: Buffer;
     readonly loadedStorage?: LoadedStorage;
 }
@@ -43,5 +41,5 @@ export interface IDeploymentParameters extends Omit<ITransactionParameters, 'to'
     readonly bytecode: Buffer;
     readonly calldata?: Buffer;
     readonly randomBytes?: Buffer;
-    readonly preimage: Buffer;
+    readonly challenge: ChallengeSolution;
 }

package/browser/transaction/mineable/TimelockGenerator.d.ts

@@ -0,0 +1,9 @@
+import { Network } from '@btc-vision/bitcoin';
+export interface ITimeLockOutput {
+    address: string;
+    witnessScript: Buffer;
+}
+export declare class TimeLockGenerator {
+    private static readonly CSV_BLOCKS;
+    static generateTimeLockAddress(publicKey: Buffer, network?: Network, csvBlocks?: number): ITimeLockOutput;
+}

package/browser/utils/StringToBuffer.d.ts

@@ -0,0 +1 @@
+export declare function stringToBuffer(str: string): Buffer;

package/browser/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/browser/verification/TapscriptVerificator.d.ts

@@ -1,11 +1,14 @@
 import { Network, Taptree } from '@btc-vision/bitcoin';
+import { ChallengeSolution } from '../epoch/ChallengeSolution.js';
+import { Feature, Features } from '../generators/Features.js';
 export interface ContractAddressVerificationParams {
     readonly deployerPubKey: Buffer;
     readonly contractSaltPubKey: Buffer;
     readonly originalSalt: Buffer;
     readonly bytecode: Buffer;
-    readonly preimage: Buffer;
+    readonly challenge: ChallengeSolution;
     readonly priorityFee: bigint;
+    readonly features: Feature<Features>[];
     readonly calldata?: Buffer;
     readonly network?: Network;
 }

package/build/_version.d.ts

@@ -1 +1 @@
-export declare const version = "1.5.3";
+export declare const version = "1.6.1";

package/build/_version.js

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

package/build/epoch/ChallengeSolution.d.ts

@@ -0,0 +1,45 @@
+import { IChallengeSolution, IChallengeSubmission, IChallengeVerification, RawChallenge, RawChallengeSubmission, RawChallengeVerification } from './interfaces/IChallengeSolution.js';
+import { Address } from '../keypair/Address.js';
+export declare class ChallengeVerification implements IChallengeVerification {
+    readonly epochHash: Buffer;
+    readonly epochRoot: Buffer;
+    readonly targetHash: Buffer;
+    readonly targetChecksum: Buffer;
+    readonly startBlock: bigint;
+    readonly endBlock: bigint;
+    readonly proofs: readonly Buffer[];
+    constructor(data: RawChallengeVerification);
+}
+export declare class ChallengeSubmission implements IChallengeSubmission {
+    readonly epochNumber: bigint;
+    readonly publicKey: Address;
+    readonly solution: Buffer;
+    readonly graffiti: Buffer | undefined;
+    readonly signature: Buffer;
+    constructor(data: RawChallengeSubmission, epochNumber: bigint);
+    verifySignature(): boolean;
+}
+export declare class ChallengeSolution implements IChallengeSolution {
+    readonly epochNumber: bigint;
+    readonly publicKey: Address;
+    readonly solution: Buffer;
+    readonly salt: Buffer;
+    readonly graffiti: Buffer;
+    readonly difficulty: number;
+    readonly verification: ChallengeVerification;
+    private readonly submission?;
+    constructor(data: RawChallenge);
+    static validateRaw(data: RawChallenge): Promise<boolean>;
+    verifySubmissionSignature(): boolean;
+    getSubmission(): ChallengeSubmission | undefined;
+    verify(): Promise<boolean>;
+    toBuffer(): Buffer;
+    toHex(): string;
+    toRaw(): RawChallenge;
+    calculateSolution(): Promise<Buffer>;
+    checkDifficulty(minDifficulty: number): {
+        valid: boolean;
+        difficulty: number;
+    };
+    getMiningTargetBlock(): bigint | null;
+}

package/build/epoch/ChallengeSolution.js

@@ -0,0 +1,105 @@
+import { stringToBuffer } from '../utils/StringToBuffer.js';
+import { Address } from '../keypair/Address.js';
+import { EpochValidator } from './validator/EpochValidator.js';
+import { BinaryWriter } from '../buffer/BinaryWriter.js';
+import { MessageSigner } from '../keypair/MessageSigner.js';
+export class ChallengeVerification {
+    constructor(data) {
+        this.epochHash = stringToBuffer(data.epochHash);
+        this.epochRoot = stringToBuffer(data.epochRoot);
+        this.targetHash = stringToBuffer(data.targetHash);
+        this.targetChecksum = stringToBuffer(data.targetChecksum);
+        this.startBlock = BigInt(data.startBlock);
+        this.endBlock = BigInt(data.endBlock);
+        this.proofs = Object.freeze(data.proofs.map((proof) => stringToBuffer(proof)));
+    }
+}
+export class ChallengeSubmission {
+    constructor(data, epochNumber) {
+        this.epochNumber = epochNumber;
+        this.publicKey = Address.fromString(data.publicKey);
+        this.solution = stringToBuffer(data.solution);
+        this.graffiti = data.graffiti ? stringToBuffer(data.graffiti) : undefined;
+        this.signature = stringToBuffer(data.signature);
+    }
+    verifySignature() {
+        const signatureDataWriter = new BinaryWriter();
+        signatureDataWriter.writeAddress(this.publicKey);
+        signatureDataWriter.writeU64(this.epochNumber);
+        signatureDataWriter.writeBytes(this.solution);
+        if (this.graffiti) {
+            signatureDataWriter.writeBytes(this.graffiti);
+        }
+        const buffer = signatureDataWriter.getBuffer();
+        return MessageSigner.verifySignature(this.publicKey, buffer, this.signature);
+    }
+}
+export class ChallengeSolution {
+    constructor(data) {
+        this.epochNumber = BigInt(data.epochNumber);
+        this.publicKey = Address.fromString(data.publicKey);
+        this.solution = stringToBuffer(data.solution);
+        this.salt = stringToBuffer(data.salt);
+        this.graffiti = stringToBuffer(data.graffiti);
+        this.difficulty = data.difficulty;
+        this.verification = new ChallengeVerification(data.verification);
+        this.submission = data.submission
+            ? new ChallengeSubmission(data.submission, this.epochNumber + 2n)
+            : data.submission;
+    }
+    static async validateRaw(data) {
+        return EpochValidator.validateEpochWinner(data);
+    }
+    verifySubmissionSignature() {
+        if (!this.submission) {
+            throw new Error('No submission provided in request.');
+        }
+        return this.submission.verifySignature();
+    }
+    getSubmission() {
+        if (!this.submission) {
+            return;
+        }
+        if (!this.verifySubmissionSignature()) {
+            throw new Error('Invalid submission signature.');
+        }
+        return this.submission;
+    }
+    async verify() {
+        return EpochValidator.validateChallengeSolution(this);
+    }
+    toBuffer() {
+        return this.solution;
+    }
+    toHex() {
+        return '0x' + this.solution.toString('hex');
+    }
+    toRaw() {
+        return {
+            epochNumber: this.epochNumber.toString(),
+            publicKey: this.publicKey.toHex(),
+            solution: this.toHex(),
+            salt: '0x' + this.salt.toString('hex'),
+            graffiti: '0x' + this.graffiti.toString('hex'),
+            difficulty: this.difficulty,
+            verification: {
+                epochHash: '0x' + this.verification.epochHash.toString('hex'),
+                epochRoot: '0x' + this.verification.epochRoot.toString('hex'),
+                targetHash: '0x' + this.verification.targetHash.toString('hex'),
+                targetChecksum: '0x' + this.verification.targetChecksum.toString('hex'),
+                startBlock: this.verification.startBlock.toString(),
+                endBlock: this.verification.endBlock.toString(),
+                proofs: this.verification.proofs.map((p) => '0x' + p.toString('hex')),
+            },
+        };
+    }
+    async calculateSolution() {
+        return EpochValidator.calculateSolution(this.verification.targetChecksum, this.publicKey.toBuffer(), this.salt);
+    }
+    checkDifficulty(minDifficulty) {
+        return EpochValidator.checkDifficulty(this.solution, this.verification.targetHash, minDifficulty);
+    }
+    getMiningTargetBlock() {
+        return EpochValidator.getMiningTargetBlock(this.epochNumber);
+    }
+}

package/build/epoch/interfaces/IChallengeSolution.d.ts

@@ -0,0 +1,50 @@
+import { Address } from '../../keypair/Address.js';
+export interface IChallengeVerification {
+    readonly epochHash: Buffer;
+    readonly epochRoot: Buffer;
+    readonly targetHash: Buffer;
+    readonly targetChecksum: Buffer;
+    readonly startBlock: bigint;
+    readonly endBlock: bigint;
+    readonly proofs: readonly Buffer[];
+}
+export interface IChallengeSolution {
+    readonly epochNumber: bigint;
+    readonly publicKey: Address;
+    readonly solution: Buffer;
+    readonly salt: Buffer;
+    readonly graffiti: Buffer;
+    readonly difficulty: number;
+    readonly verification: IChallengeVerification;
+}
+export interface RawChallengeVerification {
+    readonly epochHash: string;
+    readonly epochRoot: string;
+    readonly targetHash: string;
+    readonly targetChecksum: string;
+    readonly startBlock: string;
+    readonly endBlock: string;
+    readonly proofs: readonly string[];
+}
+export interface RawChallengeSubmission {
+    readonly publicKey: string;
+    readonly solution: string;
+    readonly graffiti?: string;
+    readonly signature: string;
+}
+export interface IChallengeSubmission {
+    readonly publicKey: Address;
+    readonly solution: Buffer;
+    readonly graffiti?: Buffer;
+    readonly signature: Buffer;
+}
+export interface RawChallenge {
+    readonly epochNumber: string;
+    readonly publicKey: string;
+    readonly solution: string;
+    readonly salt: string;
+    readonly graffiti: string;
+    readonly difficulty: number;
+    readonly verification: RawChallengeVerification;
+    readonly submission?: RawChallengeSubmission;
+}

package/build/epoch/interfaces/IChallengeSolution.js

@@ -0,0 +1 @@
+export {};

package/build/epoch/validator/EpochValidator.d.ts

@@ -0,0 +1,19 @@
+import { IChallengeSolution, RawChallenge } from '../interfaces/IChallengeSolution.js';
+export declare class EpochValidator {
+    private static readonly BLOCKS_PER_EPOCH;
+    private static readonly GRAFFITI_LENGTH;
+    static bufferToUint8Array(buffer: Buffer): Uint8Array;
+    static uint8ArrayToBuffer(array: Uint8Array): Buffer;
+    static sha1(data: Uint8Array): Promise<Uint8Array>;
+    static calculatePreimage(checksumRoot: Buffer, publicKey: Buffer, salt: Buffer): Buffer;
+    static countMatchingBits(hash1: Buffer, hash2: Buffer): number;
+    static verifySolution(challenge: IChallengeSolution, log?: boolean): Promise<boolean>;
+    static getMiningTargetBlock(epochNumber: bigint): bigint | null;
+    static validateEpochWinner(epochData: RawChallenge): Promise<boolean>;
+    static validateChallengeSolution(challenge: IChallengeSolution): Promise<boolean>;
+    static calculateSolution(targetChecksum: Buffer, publicKey: Buffer, salt: Buffer): Promise<Buffer>;
+    static checkDifficulty(solution: Buffer, targetHash: Buffer, minDifficulty: number): {
+        valid: boolean;
+        difficulty: number;
+    };
+}

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(challenge, log = false) {
+        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;
+        }
+    }
+    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 validateChallengeSolution(challenge) {
+        return await this.verifySolution(challenge);
+    }
+    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;