@btc-vision/transaction 1.5.4 → 1.6.1

package/browser/_version.d.ts

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

package/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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/browser/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, challenge: ChallengeSolution, maxPriority: bigint, calldata?: Buffer, features?: Feature<Features>[]): Buffer;
     private getAsm;
 }

package/browser/generators/builders/LegacyCalldataGenerator.d.ts

@@ -4,5 +4,5 @@ import { Feature, Features } from '../Features.js';
 export declare class LegacyCalldataGenerator extends Generator {
     constructor(senderPubKey: 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: Buffer, maxPriority: bigint, features?: Feature<Features>[]): Buffer;
 }