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

package/src/evm/btcrelay/headers/EVMBtcHeader.ts

@@ -1,110 +1,110 @@
-import {BtcHeader} from "@atomiqlabs/base";
-import {Buffer} from "buffer";
-import {sha256} from "@noble/hashes/sha2";
-
-export type EVMBtcHeaderType = {
-    version: number;
-    previousBlockhash?: Buffer;
-    merkleRoot: Buffer;
-    timestamp: number;
-    nbits: number;
-    nonce: number;
-    hash?: Buffer;
-};
-
-export class EVMBtcHeader implements BtcHeader {
-
-    version: number;
-    previousBlockhash: Buffer;
-    merkleRoot: Buffer;
-    timestamp: number;
-    nbits: number;
-    nonce: number;
-    hash?: Buffer;
-
-    constructor(data: EVMBtcHeaderType) {
-        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(): Buffer {
-        return this.merkleRoot;
-    }
-
-    getNbits(): number {
-        return this.nbits;
-    }
-
-    getNonce(): number {
-        return this.nonce;
-    }
-
-    getReversedPrevBlockhash(): Buffer {
-        return this.previousBlockhash;
-    }
-
-    getTimestamp(): number {
-        return this.timestamp;
-    }
-
-    getVersion(): number {
-        return this.version;
-    }
-
-    getHash(): Buffer {
-        return Buffer.from(sha256(sha256(this.serialize())));
-    }
-
-    serializeCompact(): Buffer {
-        const buffer = 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(): Buffer {
-        const buffer = 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: Buffer): EVMBtcHeader {
-        if(rawData.length===80) {
-            //Regular blockheader
-            const version = rawData.readUInt32LE(0);
-            const previousBlockhash = Buffer.alloc(32);
-            rawData.copy(previousBlockhash, 0, 4, 36);
-            const merkleRoot = 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.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");
-        }
-    }
-
+import {BtcHeader} from "@atomiqlabs/base";
+import {Buffer} from "buffer";
+import {sha256} from "@noble/hashes/sha2";
+
+export type EVMBtcHeaderType = {
+    version: number;
+    previousBlockhash?: Buffer;
+    merkleRoot: Buffer;
+    timestamp: number;
+    nbits: number;
+    nonce: number;
+    hash?: Buffer;
+};
+
+export class EVMBtcHeader implements BtcHeader {
+
+    version: number;
+    previousBlockhash: Buffer;
+    merkleRoot: Buffer;
+    timestamp: number;
+    nbits: number;
+    nonce: number;
+    hash?: Buffer;
+
+    constructor(data: EVMBtcHeaderType) {
+        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(): Buffer {
+        return this.merkleRoot;
+    }
+
+    getNbits(): number {
+        return this.nbits;
+    }
+
+    getNonce(): number {
+        return this.nonce;
+    }
+
+    getReversedPrevBlockhash(): Buffer {
+        return this.previousBlockhash;
+    }
+
+    getTimestamp(): number {
+        return this.timestamp;
+    }
+
+    getVersion(): number {
+        return this.version;
+    }
+
+    getHash(): Buffer {
+        return Buffer.from(sha256(sha256(this.serialize())));
+    }
+
+    serializeCompact(): Buffer {
+        const buffer = 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(): Buffer {
+        const buffer = 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: Buffer): EVMBtcHeader {
+        if(rawData.length===80) {
+            //Regular blockheader
+            const version = rawData.readUInt32LE(0);
+            const previousBlockhash = Buffer.alloc(32);
+            rawData.copy(previousBlockhash, 0, 4, 36);
+            const merkleRoot = 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.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");
+        }
+    }
+
 }

package/src/evm/btcrelay/headers/EVMBtcStoredHeader.ts

@@ -1,153 +1,153 @@
-import {BigIntBufferUtils, BtcStoredHeader, StatePredictorUtils} from "@atomiqlabs/base";
-import {EVMBtcHeader, EVMBtcHeaderType} from "./EVMBtcHeader";
-import {Buffer} from "buffer";
-import {keccak256} from "ethers";
-
-export type StarknetBtcStoredHeaderType = {
-    blockheader: EVMBtcHeader | EVMBtcHeaderType,
-    blockHash: Buffer,
-    chainWork: bigint,
-    blockHeight: number,
-    lastDiffAdjustment: number,
-    prevBlockTimestamps: number[]
-}
-
-export class EVMBtcStoredHeader implements BtcStoredHeader<EVMBtcHeader> {
-
-    blockheader: EVMBtcHeader;
-    blockHash: Buffer;
-    chainWork: bigint;
-    blockHeight: number;
-    lastDiffAdjustment: number;
-    prevBlockTimestamps: number[];
-
-    constructor(obj: StarknetBtcStoredHeaderType) {
-        this.blockheader = obj.blockheader instanceof EVMBtcHeader ? obj.blockheader : new EVMBtcHeader(obj.blockheader);
-        this.blockHash = obj.blockHash;
-        this.chainWork = obj.chainWork;
-        this.blockHeight = obj.blockHeight;
-        this.lastDiffAdjustment = obj.lastDiffAdjustment;
-        this.prevBlockTimestamps = obj.prevBlockTimestamps;
-    }
-
-    getBlockheight(): number {
-        return this.blockHeight;
-    }
-
-    getChainWork(): Buffer {
-        return Buffer.from(this.chainWork.toString(16).padStart(64, "0"), "hex");
-    }
-
-    getHeader(): EVMBtcHeader {
-        return this.blockheader;
-    }
-
-    getLastDiffAdjustment(): number {
-        return this.lastDiffAdjustment;
-    }
-
-    getPrevBlockTimestamps(): number[] {
-        return this.prevBlockTimestamps;
-    }
-
-    getBlockHash(): Buffer {
-        return 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
-     */
-    private computeNextBlockTimestamps(): number[] {
-        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
-     */
-    private computeNextChainWork(nbits: number): bigint {
-        return this.chainWork + BigIntBufferUtils.fromBuffer(StatePredictorUtils.getChainwork(nbits));
-    }
-
-    /**
-     * Computes lastDiffAdjustment, this changes only once every DIFF_ADJUSTMENT_PERIOD blocks
-     *
-     * @param headerTimestamp
-     * @private
-     */
-    private computeNextLastDiffAdjustment(headerTimestamp: number) {
-        const blockheight = this.blockHeight+1;
-
-        let lastDiffAdjustment = this.lastDiffAdjustment;
-        if(blockheight % StatePredictorUtils.DIFF_ADJUSTMENT_PERIOD === 0) {
-            lastDiffAdjustment = headerTimestamp;
-        }
-
-        return lastDiffAdjustment;
-    }
-
-    computeNext(header: EVMBtcHeader): EVMBtcStoredHeader {
-        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(): string {
-        return keccak256(this.serialize());
-    }
-
-    serialize(): Buffer {
-        const buffer = Buffer.alloc(160);
-        this.blockheader.serialize().copy(buffer, 0, 0, 80);
-        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(): {data: [string, string, string, string, string]} {
-        const buffer = this.serialize();
-        const result: string[] = [];
-        for(let i=0;i<5;i++) {
-            result[i] = "0x"+buffer.subarray(i*32, (i+1)*32).toString("hex");
-        }
-        return {data: result as any};
-    }
-
-    static deserialize(data: Buffer): EVMBtcStoredHeader {
-        if(data.length!==160) throw new Error(`Invalid size Expected 160, got: ${data.length}!`);
-        const blockheader = EVMBtcHeader.deserialize(data.subarray(0, 80));
-        const prevBlockTimestamps: number[] = [];
-        for(let i=0;i<10;i++) {
-            prevBlockTimestamps[i] = data.readUint32BE(120 + (i*4));
-        }
-        return new EVMBtcStoredHeader({
-            blockheader,
-            blockHash: blockheader.getHash(),
-            chainWork: BigIntBufferUtils.fromBuffer(data.subarray(80, 112)),
-            blockHeight: data.readUint32BE(112),
-            lastDiffAdjustment: data.readUint32BE(116),
-            prevBlockTimestamps
-        });
-    }
-
+import {BigIntBufferUtils, BtcStoredHeader, StatePredictorUtils} from "@atomiqlabs/base";
+import {EVMBtcHeader, EVMBtcHeaderType} from "./EVMBtcHeader";
+import {Buffer} from "buffer";
+import {keccak256} from "ethers";
+
+export type StarknetBtcStoredHeaderType = {
+    blockheader: EVMBtcHeader | EVMBtcHeaderType,
+    blockHash: Buffer,
+    chainWork: bigint,
+    blockHeight: number,
+    lastDiffAdjustment: number,
+    prevBlockTimestamps: number[]
+}
+
+export class EVMBtcStoredHeader implements BtcStoredHeader<EVMBtcHeader> {
+
+    blockheader: EVMBtcHeader;
+    blockHash: Buffer;
+    chainWork: bigint;
+    blockHeight: number;
+    lastDiffAdjustment: number;
+    prevBlockTimestamps: number[];
+
+    constructor(obj: StarknetBtcStoredHeaderType) {
+        this.blockheader = obj.blockheader instanceof EVMBtcHeader ? obj.blockheader : new EVMBtcHeader(obj.blockheader);
+        this.blockHash = obj.blockHash;
+        this.chainWork = obj.chainWork;
+        this.blockHeight = obj.blockHeight;
+        this.lastDiffAdjustment = obj.lastDiffAdjustment;
+        this.prevBlockTimestamps = obj.prevBlockTimestamps;
+    }
+
+    getBlockheight(): number {
+        return this.blockHeight;
+    }
+
+    getChainWork(): Buffer {
+        return Buffer.from(this.chainWork.toString(16).padStart(64, "0"), "hex");
+    }
+
+    getHeader(): EVMBtcHeader {
+        return this.blockheader;
+    }
+
+    getLastDiffAdjustment(): number {
+        return this.lastDiffAdjustment;
+    }
+
+    getPrevBlockTimestamps(): number[] {
+        return this.prevBlockTimestamps;
+    }
+
+    getBlockHash(): Buffer {
+        return 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
+     */
+    private computeNextBlockTimestamps(): number[] {
+        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
+     */
+    private computeNextChainWork(nbits: number): bigint {
+        return this.chainWork + BigIntBufferUtils.fromBuffer(StatePredictorUtils.getChainwork(nbits));
+    }
+
+    /**
+     * Computes lastDiffAdjustment, this changes only once every DIFF_ADJUSTMENT_PERIOD blocks
+     *
+     * @param headerTimestamp
+     * @private
+     */
+    private computeNextLastDiffAdjustment(headerTimestamp: number) {
+        const blockheight = this.blockHeight+1;
+
+        let lastDiffAdjustment = this.lastDiffAdjustment;
+        if(blockheight % StatePredictorUtils.DIFF_ADJUSTMENT_PERIOD === 0) {
+            lastDiffAdjustment = headerTimestamp;
+        }
+
+        return lastDiffAdjustment;
+    }
+
+    computeNext(header: EVMBtcHeader): EVMBtcStoredHeader {
+        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(): string {
+        return keccak256(this.serialize());
+    }
+
+    serialize(): Buffer {
+        const buffer = Buffer.alloc(160);
+        this.blockheader.serialize().copy(buffer, 0, 0, 80);
+        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(): {data: [string, string, string, string, string]} {
+        const buffer = this.serialize();
+        const result: string[] = [];
+        for(let i=0;i<5;i++) {
+            result[i] = "0x"+buffer.subarray(i*32, (i+1)*32).toString("hex");
+        }
+        return {data: result as any};
+    }
+
+    static deserialize(data: Buffer): EVMBtcStoredHeader {
+        if(data.length!==160) throw new Error(`Invalid size Expected 160, got: ${data.length}!`);
+        const blockheader = EVMBtcHeader.deserialize(data.subarray(0, 80));
+        const prevBlockTimestamps: number[] = [];
+        for(let i=0;i<10;i++) {
+            prevBlockTimestamps[i] = data.readUint32BE(120 + (i*4));
+        }
+        return new EVMBtcStoredHeader({
+            blockheader,
+            blockHash: blockheader.getHash(),
+            chainWork: BigIntBufferUtils.fromBuffer(data.subarray(80, 112)),
+            blockHeight: data.readUint32BE(112),
+            lastDiffAdjustment: data.readUint32BE(116),
+            prevBlockTimestamps
+        });
+    }
+
 }