@atomiqlabs/chain-evm 1.0.0-dev.62 → 1.0.0-dev.64

package/dist/evm/btcrelay/headers/EVMBtcHeader.d.ts

@@ -1,33 +1,33 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { BtcHeader } from "@atomiqlabs/base";
-import { Buffer } from "buffer";
-export type EVMBtcHeaderType = {
-    version: number;
-    previousBlockhash?: Buffer;
-    merkleRoot: Buffer;
-    timestamp: number;
-    nbits: number;
-    nonce: number;
-    hash?: Buffer;
-};
-export declare class EVMBtcHeader implements BtcHeader {
-    version: number;
-    previousBlockhash: Buffer;
-    merkleRoot: Buffer;
-    timestamp: number;
-    nbits: number;
-    nonce: number;
-    hash?: Buffer;
-    constructor(data: EVMBtcHeaderType);
-    getMerkleRoot(): Buffer;
-    getNbits(): number;
-    getNonce(): number;
-    getReversedPrevBlockhash(): Buffer;
-    getTimestamp(): number;
-    getVersion(): number;
-    getHash(): Buffer;
-    serializeCompact(): Buffer;
-    serialize(): Buffer;
-    static deserialize(rawData: Buffer): EVMBtcHeader;
-}
+/// <reference types="node" />
+/// <reference types="node" />
+import { BtcHeader } from "@atomiqlabs/base";
+import { Buffer } from "buffer";
+export type EVMBtcHeaderType = {
+    version: number;
+    previousBlockhash?: Buffer;
+    merkleRoot: Buffer;
+    timestamp: number;
+    nbits: number;
+    nonce: number;
+    hash?: Buffer;
+};
+export declare class EVMBtcHeader implements BtcHeader {
+    version: number;
+    previousBlockhash: Buffer;
+    merkleRoot: Buffer;
+    timestamp: number;
+    nbits: number;
+    nonce: number;
+    hash?: Buffer;
+    constructor(data: EVMBtcHeaderType);
+    getMerkleRoot(): Buffer;
+    getNbits(): number;
+    getNonce(): number;
+    getReversedPrevBlockhash(): Buffer;
+    getTimestamp(): number;
+    getVersion(): number;
+    getHash(): Buffer;
+    serializeCompact(): Buffer;
+    serialize(): Buffer;
+    static deserialize(rawData: Buffer): EVMBtcHeader;
+}

package/dist/evm/btcrelay/headers/EVMBtcHeader.js

@@ -1,84 +1,84 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EVMBtcHeader = void 0;
-const buffer_1 = require("buffer");
-const sha2_1 = require("@noble/hashes/sha2");
-class EVMBtcHeader {
-    constructor(data) {
-        this.version = data.version;
-        this.previousBlockhash = data.previousBlockhash;
-        this.merkleRoot = data.merkleRoot;
-        this.timestamp = data.timestamp;
-        this.nbits = data.nbits;
-        this.nonce = data.nonce;
-        this.hash = data.hash;
-    }
-    getMerkleRoot() {
-        return this.merkleRoot;
-    }
-    getNbits() {
-        return this.nbits;
-    }
-    getNonce() {
-        return this.nonce;
-    }
-    getReversedPrevBlockhash() {
-        return this.previousBlockhash;
-    }
-    getTimestamp() {
-        return this.timestamp;
-    }
-    getVersion() {
-        return this.version;
-    }
-    getHash() {
-        return buffer_1.Buffer.from((0, sha2_1.sha256)((0, sha2_1.sha256)(this.serialize())));
-    }
-    serializeCompact() {
-        const buffer = buffer_1.Buffer.alloc(48);
-        buffer.writeUInt32LE(this.version, 0);
-        this.merkleRoot.copy(buffer, 4);
-        buffer.writeUInt32LE(this.timestamp, 36);
-        buffer.writeUInt32LE(this.nbits, 40);
-        buffer.writeUInt32LE(this.nonce, 44);
-        return buffer;
-    }
-    serialize() {
-        const buffer = buffer_1.Buffer.alloc(80);
-        buffer.writeUInt32LE(this.version, 0);
-        this.previousBlockhash.copy(buffer, 4);
-        this.merkleRoot.copy(buffer, 36);
-        buffer.writeUInt32LE(this.timestamp, 68);
-        buffer.writeUInt32LE(this.nbits, 72);
-        buffer.writeUInt32LE(this.nonce, 76);
-        return buffer;
-    }
-    static deserialize(rawData) {
-        if (rawData.length === 80) {
-            //Regular blockheader
-            const version = rawData.readUInt32LE(0);
-            const previousBlockhash = buffer_1.Buffer.alloc(32);
-            rawData.copy(previousBlockhash, 0, 4, 36);
-            const merkleRoot = buffer_1.Buffer.alloc(32);
-            rawData.copy(merkleRoot, 0, 36, 68);
-            const timestamp = rawData.readUInt32LE(68);
-            const nbits = rawData.readUInt32LE(72);
-            const nonce = rawData.readUInt32LE(76);
-            return new EVMBtcHeader({ version, previousBlockhash, merkleRoot, timestamp, nbits, nonce });
-        }
-        else if (rawData.length === 48) {
-            //Compact blockheader
-            const version = rawData.readUInt32LE(0);
-            const merkleRoot = buffer_1.Buffer.alloc(32);
-            rawData.copy(merkleRoot, 0, 4, 36);
-            const timestamp = rawData.readUInt32LE(36);
-            const nbits = rawData.readUInt32LE(40);
-            const nonce = rawData.readUInt32LE(44);
-            return new EVMBtcHeader({ version, merkleRoot, timestamp, nbits, nonce });
-        }
-        else {
-            throw new Error("Invalid byte length");
-        }
-    }
-}
-exports.EVMBtcHeader = EVMBtcHeader;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMBtcHeader = void 0;
+const buffer_1 = require("buffer");
+const sha2_1 = require("@noble/hashes/sha2");
+class EVMBtcHeader {
+    constructor(data) {
+        this.version = data.version;
+        this.previousBlockhash = data.previousBlockhash;
+        this.merkleRoot = data.merkleRoot;
+        this.timestamp = data.timestamp;
+        this.nbits = data.nbits;
+        this.nonce = data.nonce;
+        this.hash = data.hash;
+    }
+    getMerkleRoot() {
+        return this.merkleRoot;
+    }
+    getNbits() {
+        return this.nbits;
+    }
+    getNonce() {
+        return this.nonce;
+    }
+    getReversedPrevBlockhash() {
+        return this.previousBlockhash;
+    }
+    getTimestamp() {
+        return this.timestamp;
+    }
+    getVersion() {
+        return this.version;
+    }
+    getHash() {
+        return buffer_1.Buffer.from((0, sha2_1.sha256)((0, sha2_1.sha256)(this.serialize())));
+    }
+    serializeCompact() {
+        const buffer = buffer_1.Buffer.alloc(48);
+        buffer.writeUInt32LE(this.version, 0);
+        this.merkleRoot.copy(buffer, 4);
+        buffer.writeUInt32LE(this.timestamp, 36);
+        buffer.writeUInt32LE(this.nbits, 40);
+        buffer.writeUInt32LE(this.nonce, 44);
+        return buffer;
+    }
+    serialize() {
+        const buffer = buffer_1.Buffer.alloc(80);
+        buffer.writeUInt32LE(this.version, 0);
+        this.previousBlockhash.copy(buffer, 4);
+        this.merkleRoot.copy(buffer, 36);
+        buffer.writeUInt32LE(this.timestamp, 68);
+        buffer.writeUInt32LE(this.nbits, 72);
+        buffer.writeUInt32LE(this.nonce, 76);
+        return buffer;
+    }
+    static deserialize(rawData) {
+        if (rawData.length === 80) {
+            //Regular blockheader
+            const version = rawData.readUInt32LE(0);
+            const previousBlockhash = buffer_1.Buffer.alloc(32);
+            rawData.copy(previousBlockhash, 0, 4, 36);
+            const merkleRoot = buffer_1.Buffer.alloc(32);
+            rawData.copy(merkleRoot, 0, 36, 68);
+            const timestamp = rawData.readUInt32LE(68);
+            const nbits = rawData.readUInt32LE(72);
+            const nonce = rawData.readUInt32LE(76);
+            return new EVMBtcHeader({ version, previousBlockhash, merkleRoot, timestamp, nbits, nonce });
+        }
+        else if (rawData.length === 48) {
+            //Compact blockheader
+            const version = rawData.readUInt32LE(0);
+            const merkleRoot = buffer_1.Buffer.alloc(32);
+            rawData.copy(merkleRoot, 0, 4, 36);
+            const timestamp = rawData.readUInt32LE(36);
+            const nbits = rawData.readUInt32LE(40);
+            const nonce = rawData.readUInt32LE(44);
+            return new EVMBtcHeader({ version, merkleRoot, timestamp, nbits, nonce });
+        }
+        else {
+            throw new Error("Invalid byte length");
+        }
+    }
+}
+exports.EVMBtcHeader = EVMBtcHeader;

package/dist/evm/btcrelay/headers/EVMBtcStoredHeader.d.ts

@@ -1,56 +1,56 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { BtcStoredHeader } from "@atomiqlabs/base";
-import { EVMBtcHeader, EVMBtcHeaderType } from "./EVMBtcHeader";
-import { Buffer } from "buffer";
-export type StarknetBtcStoredHeaderType = {
-    blockheader: EVMBtcHeader | EVMBtcHeaderType;
-    blockHash: Buffer;
-    chainWork: bigint;
-    blockHeight: number;
-    lastDiffAdjustment: number;
-    prevBlockTimestamps: number[];
-};
-export declare class EVMBtcStoredHeader implements BtcStoredHeader<EVMBtcHeader> {
-    blockheader: EVMBtcHeader;
-    blockHash: Buffer;
-    chainWork: bigint;
-    blockHeight: number;
-    lastDiffAdjustment: number;
-    prevBlockTimestamps: number[];
-    constructor(obj: StarknetBtcStoredHeaderType);
-    getBlockheight(): number;
-    getChainWork(): Buffer;
-    getHeader(): EVMBtcHeader;
-    getLastDiffAdjustment(): number;
-    getPrevBlockTimestamps(): number[];
-    getBlockHash(): Buffer;
-    /**
-     * Computes prevBlockTimestamps for a next block, shifting the old block timestamps to the left & appending
-     *  this block's timestamp to the end
-     *
-     * @private
-     */
-    private computeNextBlockTimestamps;
-    /**
-     * Computes total chain work after a new header with "nbits" is added to the chain
-     *
-     * @param nbits
-     * @private
-     */
-    private computeNextChainWork;
-    /**
-     * Computes lastDiffAdjustment, this changes only once every DIFF_ADJUSTMENT_PERIOD blocks
-     *
-     * @param headerTimestamp
-     * @private
-     */
-    private computeNextLastDiffAdjustment;
-    computeNext(header: EVMBtcHeader): EVMBtcStoredHeader;
-    getCommitHash(): string;
-    serialize(): Buffer;
-    serializeToStruct(): {
-        data: [string, string, string, string, string];
-    };
-    static deserialize(data: Buffer): EVMBtcStoredHeader;
-}
+/// <reference types="node" />
+/// <reference types="node" />
+import { BtcStoredHeader } from "@atomiqlabs/base";
+import { EVMBtcHeader, EVMBtcHeaderType } from "./EVMBtcHeader";
+import { Buffer } from "buffer";
+export type StarknetBtcStoredHeaderType = {
+    blockheader: EVMBtcHeader | EVMBtcHeaderType;
+    blockHash: Buffer;
+    chainWork: bigint;
+    blockHeight: number;
+    lastDiffAdjustment: number;
+    prevBlockTimestamps: number[];
+};
+export declare class EVMBtcStoredHeader implements BtcStoredHeader<EVMBtcHeader> {
+    blockheader: EVMBtcHeader;
+    blockHash: Buffer;
+    chainWork: bigint;
+    blockHeight: number;
+    lastDiffAdjustment: number;
+    prevBlockTimestamps: number[];
+    constructor(obj: StarknetBtcStoredHeaderType);
+    getBlockheight(): number;
+    getChainWork(): Buffer;
+    getHeader(): EVMBtcHeader;
+    getLastDiffAdjustment(): number;
+    getPrevBlockTimestamps(): number[];
+    getBlockHash(): Buffer;
+    /**
+     * Computes prevBlockTimestamps for a next block, shifting the old block timestamps to the left & appending
+     *  this block's timestamp to the end
+     *
+     * @private
+     */
+    private computeNextBlockTimestamps;
+    /**
+     * Computes total chain work after a new header with "nbits" is added to the chain
+     *
+     * @param nbits
+     * @private
+     */
+    private computeNextChainWork;
+    /**
+     * Computes lastDiffAdjustment, this changes only once every DIFF_ADJUSTMENT_PERIOD blocks
+     *
+     * @param headerTimestamp
+     * @private
+     */
+    private computeNextLastDiffAdjustment;
+    computeNext(header: EVMBtcHeader): EVMBtcStoredHeader;
+    getCommitHash(): string;
+    serialize(): Buffer;
+    serializeToStruct(): {
+        data: [string, string, string, string, string];
+    };
+    static deserialize(data: Buffer): EVMBtcStoredHeader;
+}

package/dist/evm/btcrelay/headers/EVMBtcStoredHeader.js

@@ -1,123 +1,123 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EVMBtcStoredHeader = void 0;
-const base_1 = require("@atomiqlabs/base");
-const EVMBtcHeader_1 = require("./EVMBtcHeader");
-const buffer_1 = require("buffer");
-const ethers_1 = require("ethers");
-class EVMBtcStoredHeader {
-    constructor(obj) {
-        this.blockheader = obj.blockheader instanceof EVMBtcHeader_1.EVMBtcHeader ? obj.blockheader : new EVMBtcHeader_1.EVMBtcHeader(obj.blockheader);
-        this.blockHash = obj.blockHash;
-        this.chainWork = obj.chainWork;
-        this.blockHeight = obj.blockHeight;
-        this.lastDiffAdjustment = obj.lastDiffAdjustment;
-        this.prevBlockTimestamps = obj.prevBlockTimestamps;
-    }
-    getBlockheight() {
-        return this.blockHeight;
-    }
-    getChainWork() {
-        return buffer_1.Buffer.from(this.chainWork.toString(16).padStart(64, "0"), "hex");
-    }
-    getHeader() {
-        return this.blockheader;
-    }
-    getLastDiffAdjustment() {
-        return this.lastDiffAdjustment;
-    }
-    getPrevBlockTimestamps() {
-        return this.prevBlockTimestamps;
-    }
-    getBlockHash() {
-        return buffer_1.Buffer.from([...this.blockHash]).reverse();
-    }
-    /**
-     * Computes prevBlockTimestamps for a next block, shifting the old block timestamps to the left & appending
-     *  this block's timestamp to the end
-     *
-     * @private
-     */
-    computeNextBlockTimestamps() {
-        const prevBlockTimestamps = [...this.prevBlockTimestamps];
-        for (let i = 1; i < 10; i++) {
-            prevBlockTimestamps[i - 1] = prevBlockTimestamps[i];
-        }
-        prevBlockTimestamps[9] = this.blockheader.getTimestamp();
-        return prevBlockTimestamps;
-    }
-    /**
-     * Computes total chain work after a new header with "nbits" is added to the chain
-     *
-     * @param nbits
-     * @private
-     */
-    computeNextChainWork(nbits) {
-        return this.chainWork + base_1.BigIntBufferUtils.fromBuffer(base_1.StatePredictorUtils.getChainwork(nbits));
-    }
-    /**
-     * Computes lastDiffAdjustment, this changes only once every DIFF_ADJUSTMENT_PERIOD blocks
-     *
-     * @param headerTimestamp
-     * @private
-     */
-    computeNextLastDiffAdjustment(headerTimestamp) {
-        const blockheight = this.blockHeight + 1;
-        let lastDiffAdjustment = this.lastDiffAdjustment;
-        if (blockheight % base_1.StatePredictorUtils.DIFF_ADJUSTMENT_PERIOD === 0) {
-            lastDiffAdjustment = headerTimestamp;
-        }
-        return lastDiffAdjustment;
-    }
-    computeNext(header) {
-        header.previousBlockhash = this.blockHash;
-        return new EVMBtcStoredHeader({
-            chainWork: this.computeNextChainWork(header.getNbits()),
-            prevBlockTimestamps: this.computeNextBlockTimestamps(),
-            blockHeight: this.blockHeight + 1,
-            lastDiffAdjustment: this.computeNextLastDiffAdjustment(header.getTimestamp()),
-            blockHash: header.getHash(),
-            blockheader: header
-        });
-    }
-    getCommitHash() {
-        return (0, ethers_1.keccak256)(this.serialize());
-    }
-    serialize() {
-        const buffer = buffer_1.Buffer.alloc(160);
-        this.blockheader.serialize().copy(buffer, 0, 0, 80);
-        base_1.BigIntBufferUtils.toBuffer(this.chainWork, "be", 32).copy(buffer, 80, 0, 32);
-        buffer.writeUint32BE(this.blockHeight, 112);
-        buffer.writeUint32BE(this.lastDiffAdjustment, 116);
-        for (let i = 0; i < 10; i++) {
-            buffer.writeUint32BE(this.prevBlockTimestamps[i], 120 + (i * 4));
-        }
-        return buffer;
-    }
-    serializeToStruct() {
-        const buffer = this.serialize();
-        const result = [];
-        for (let i = 0; i < 5; i++) {
-            result[i] = "0x" + buffer.subarray(i * 32, (i + 1) * 32).toString("hex");
-        }
-        return { data: result };
-    }
-    static deserialize(data) {
-        if (data.length !== 160)
-            throw new Error(`Invalid size Expected 160, got: ${data.length}!`);
-        const blockheader = EVMBtcHeader_1.EVMBtcHeader.deserialize(data.subarray(0, 80));
-        const prevBlockTimestamps = [];
-        for (let i = 0; i < 10; i++) {
-            prevBlockTimestamps[i] = data.readUint32BE(120 + (i * 4));
-        }
-        return new EVMBtcStoredHeader({
-            blockheader,
-            blockHash: blockheader.getHash(),
-            chainWork: base_1.BigIntBufferUtils.fromBuffer(data.subarray(80, 112)),
-            blockHeight: data.readUint32BE(112),
-            lastDiffAdjustment: data.readUint32BE(116),
-            prevBlockTimestamps
-        });
-    }
-}
-exports.EVMBtcStoredHeader = EVMBtcStoredHeader;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMBtcStoredHeader = void 0;
+const base_1 = require("@atomiqlabs/base");
+const EVMBtcHeader_1 = require("./EVMBtcHeader");
+const buffer_1 = require("buffer");
+const ethers_1 = require("ethers");
+class EVMBtcStoredHeader {
+    constructor(obj) {
+        this.blockheader = obj.blockheader instanceof EVMBtcHeader_1.EVMBtcHeader ? obj.blockheader : new EVMBtcHeader_1.EVMBtcHeader(obj.blockheader);
+        this.blockHash = obj.blockHash;
+        this.chainWork = obj.chainWork;
+        this.blockHeight = obj.blockHeight;
+        this.lastDiffAdjustment = obj.lastDiffAdjustment;
+        this.prevBlockTimestamps = obj.prevBlockTimestamps;
+    }
+    getBlockheight() {
+        return this.blockHeight;
+    }
+    getChainWork() {
+        return buffer_1.Buffer.from(this.chainWork.toString(16).padStart(64, "0"), "hex");
+    }
+    getHeader() {
+        return this.blockheader;
+    }
+    getLastDiffAdjustment() {
+        return this.lastDiffAdjustment;
+    }
+    getPrevBlockTimestamps() {
+        return this.prevBlockTimestamps;
+    }
+    getBlockHash() {
+        return buffer_1.Buffer.from([...this.blockHash]).reverse();
+    }
+    /**
+     * Computes prevBlockTimestamps for a next block, shifting the old block timestamps to the left & appending
+     *  this block's timestamp to the end
+     *
+     * @private
+     */
+    computeNextBlockTimestamps() {
+        const prevBlockTimestamps = [...this.prevBlockTimestamps];
+        for (let i = 1; i < 10; i++) {
+            prevBlockTimestamps[i - 1] = prevBlockTimestamps[i];
+        }
+        prevBlockTimestamps[9] = this.blockheader.getTimestamp();
+        return prevBlockTimestamps;
+    }
+    /**
+     * Computes total chain work after a new header with "nbits" is added to the chain
+     *
+     * @param nbits
+     * @private
+     */
+    computeNextChainWork(nbits) {
+        return this.chainWork + base_1.BigIntBufferUtils.fromBuffer(base_1.StatePredictorUtils.getChainwork(nbits));
+    }
+    /**
+     * Computes lastDiffAdjustment, this changes only once every DIFF_ADJUSTMENT_PERIOD blocks
+     *
+     * @param headerTimestamp
+     * @private
+     */
+    computeNextLastDiffAdjustment(headerTimestamp) {
+        const blockheight = this.blockHeight + 1;
+        let lastDiffAdjustment = this.lastDiffAdjustment;
+        if (blockheight % base_1.StatePredictorUtils.DIFF_ADJUSTMENT_PERIOD === 0) {
+            lastDiffAdjustment = headerTimestamp;
+        }
+        return lastDiffAdjustment;
+    }
+    computeNext(header) {
+        header.previousBlockhash = this.blockHash;
+        return new EVMBtcStoredHeader({
+            chainWork: this.computeNextChainWork(header.getNbits()),
+            prevBlockTimestamps: this.computeNextBlockTimestamps(),
+            blockHeight: this.blockHeight + 1,
+            lastDiffAdjustment: this.computeNextLastDiffAdjustment(header.getTimestamp()),
+            blockHash: header.getHash(),
+            blockheader: header
+        });
+    }
+    getCommitHash() {
+        return (0, ethers_1.keccak256)(this.serialize());
+    }
+    serialize() {
+        const buffer = buffer_1.Buffer.alloc(160);
+        this.blockheader.serialize().copy(buffer, 0, 0, 80);
+        base_1.BigIntBufferUtils.toBuffer(this.chainWork, "be", 32).copy(buffer, 80, 0, 32);
+        buffer.writeUint32BE(this.blockHeight, 112);
+        buffer.writeUint32BE(this.lastDiffAdjustment, 116);
+        for (let i = 0; i < 10; i++) {
+            buffer.writeUint32BE(this.prevBlockTimestamps[i], 120 + (i * 4));
+        }
+        return buffer;
+    }
+    serializeToStruct() {
+        const buffer = this.serialize();
+        const result = [];
+        for (let i = 0; i < 5; i++) {
+            result[i] = "0x" + buffer.subarray(i * 32, (i + 1) * 32).toString("hex");
+        }
+        return { data: result };
+    }
+    static deserialize(data) {
+        if (data.length !== 160)
+            throw new Error(`Invalid size Expected 160, got: ${data.length}!`);
+        const blockheader = EVMBtcHeader_1.EVMBtcHeader.deserialize(data.subarray(0, 80));
+        const prevBlockTimestamps = [];
+        for (let i = 0; i < 10; i++) {
+            prevBlockTimestamps[i] = data.readUint32BE(120 + (i * 4));
+        }
+        return new EVMBtcStoredHeader({
+            blockheader,
+            blockHash: blockheader.getHash(),
+            chainWork: base_1.BigIntBufferUtils.fromBuffer(data.subarray(80, 112)),
+            blockHeight: data.readUint32BE(112),
+            lastDiffAdjustment: data.readUint32BE(116),
+            prevBlockTimestamps
+        });
+    }
+}
+exports.EVMBtcStoredHeader = EVMBtcStoredHeader;