fix(tests): cleanup tests to prepare for tokenomics testing

packages/protocol/contracts/test/L1/TestTaikoL1EnableTokenomics.sol

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: MIT
+//
+// ╭━━━━╮╱╱╭╮╱╱╱╱╱╭╮╱╱╱╱╱╭╮
+// ┃╭╮╭╮┃╱╱┃┃╱╱╱╱╱┃┃╱╱╱╱╱┃┃
+// ╰╯┃┃┣┻━┳┫┃╭┳━━╮┃┃╱╱╭━━┫╰━┳━━╮
+// ╱╱┃┃┃╭╮┣┫╰╯┫╭╮┃┃┃╱╭┫╭╮┃╭╮┃━━┫
+// ╱╱┃┃┃╭╮┃┃╭╮┫╰╯┃┃╰━╯┃╭╮┃╰╯┣━━┃
+// ╱╱╰╯╰╯╰┻┻╯╰┻━━╯╰━━━┻╯╰┻━━┻━━╯
+pragma solidity ^0.8.9;
+
+import {IProofVerifier} from "../../L1/ProofVerifier.sol";
+import "../../L1/TaikoL1.sol";
+
+contract TestTaikoL1EnableTokenomics is TaikoL1, IProofVerifier {
+    function getConfig()
+        public
+        pure
+        override
+        returns (TaikoData.Config memory config)
+    {
+        config.chainId = 167;
+        // up to 2048 pending blocks
+        config.maxNumBlocks = 4;
+        config.blockHashHistory = 3;
+        // This number is calculated from maxNumBlocks to make
+        // the 'the maximum value of the multiplier' close to 20.0
+        config.zkProofsPerBlock = 1;
+        config.maxVerificationsPerTx = 2;
+        config.commitConfirmations = 1;
+        config.maxProofsPerForkChoice = 5;
+        config.blockMaxGasLimit = 30000000; // TODO
+        config.maxTransactionsPerBlock = 20; // TODO
+        config.maxBytesPerTxList = 10240; // TODO
+        config.minTxGasLimit = 21000; // TODO
+        config.anchorTxGasLimit = 250000;
+        config.feePremiumLamda = 590;
+        config.rewardBurnBips = 100; // 100 basis points or 1%
+        config.proposerDepositPctg = 25; // 25%
+
+        // Moving average factors
+        config.feeBaseMAF = 1024;
+        config.blockTimeMAF = 64;
+        config.proofTimeMAF = 64;
+
+        config.rewardMultiplierPctg = 400; // 400%
+        config.feeGracePeriodPctg = 125; // 125%
+        config.feeMaxPeriodPctg = 375; // 375%
+        config.blockTimeCap = 48 seconds;
+        config.proofTimeCap = 60 minutes;
+        config.boostrapDiscountHalvingPeriod = 180 days;
+        config.initialUncleDelay = 1 minutes;
+        config.enableTokenomics = true;
+    }
+
+    function verifyZKP(
+        bytes memory /*verificationKey*/,
+        bytes calldata /*zkproof*/,
+        bytes32 /*blockHash*/,
+        address /*prover*/,
+        bytes32 /*txListHash*/
+    ) public pure override returns (bool) {
+        return true;
+    }
+
+    function verifyMKP(
+        bytes memory /*key*/,
+        bytes memory /*value*/,
+        bytes memory /*proof*/,
+        bytes32 /*root*/
+    ) public pure override returns (bool) {
+        return true;
+    }
+}

packages/protocol/tasks/utils.ts

@@ -1,7 +1,5 @@
 import * as fs from "fs";
 import * as log from "./log";
-import { Block, BlockHeader, EthGetProofResponse } from "../test/utils/rpc";
-import RLP from "rlp";
 
 async function deployContract(
     hre: any,
@@ -68,105 +66,16 @@ function getDeployments(_fileName: string) {
     return JSON.parse(`${json}`);
 }
 
-async function getMessageStatusSlot(hre: any, signal: any) {
-    return hre.ethers.utils.solidityKeccak256(
-        ["string", "bytes"],
-        ["MESSAGE_STATUS", signal]
-    );
-}
-
 async function decode(hre: any, type: any, data: any) {
     return hre.ethers.utils.defaultAbiCoder.decode([type], data).toString();
 }
 
-function getSignalSlot(hre: any, sender: any, signal: any) {
-    return hre.ethers.utils.keccak256(
-        hre.ethers.utils.solidityPack(
-            ["string", "address", "bytes32"],
-            ["SIGNAL", sender, signal]
-        )
-    );
-}
-
-const MessageStatus = {
-    NEW: 0,
-    RETRIABLE: 1,
-    DONE: 2,
-    FAILED: 3,
-};
-
-async function getLatestBlockHeader(hre: any) {
-    const block: Block = await hre.ethers.provider.send(
-        "eth_getBlockByNumber",
-        ["latest", false]
-    );
-
-    const logsBloom = block.logsBloom.toString().substring(2);
-
-    const blockHeader: BlockHeader = {
-        parentHash: block.parentHash,
-        ommersHash: block.sha3Uncles,
-        beneficiary: block.miner,
-        stateRoot: block.stateRoot,
-        transactionsRoot: block.transactionsRoot,
-        receiptsRoot: block.receiptsRoot,
-        logsBloom: logsBloom.match(/.{1,64}/g)!.map((s: string) => "0x" + s),
-        difficulty: block.difficulty,
-        height: block.number,
-        gasLimit: block.gasLimit,
-        gasUsed: block.gasUsed,
-        timestamp: block.timestamp,
-        extraData: block.extraData,
-        mixHash: block.mixHash,
-        nonce: block.nonce,
-        baseFeePerGas: block.baseFeePerGas ? parseInt(block.baseFeePerGas) : 0,
-    };
-
-    return { block, blockHeader };
-}
-
-async function getSignalProof(
-    hre: any,
-    contractAddress: string,
-    key: string,
-    blockNumber: number,
-    blockHeader: BlockHeader
-) {
-    const proof: EthGetProofResponse = await hre.ethers.provider.send(
-        "eth_getProof",
-        [contractAddress, [key], blockNumber]
-    );
-
-    // RLP encode the proof together for LibTrieProof to decode
-    const encodedProof = hre.ethers.utils.defaultAbiCoder.encode(
-        ["bytes", "bytes"],
-        [
-            RLP.encode(proof.accountProof),
-            RLP.encode(proof.storageProof[0].proof),
-        ]
-    );
-    // encode the SignalProof struct from LibBridgeSignal
-    const signalProof = hre.ethers.utils.defaultAbiCoder.encode(
-        [
-            "tuple(tuple(bytes32 parentHash, bytes32 ommersHash, address beneficiary, bytes32 stateRoot, bytes32 transactionsRoot, bytes32 receiptsRoot, bytes32[8] logsBloom, uint256 difficulty, uint128 height, uint64 gasLimit, uint64 gasUsed, uint64 timestamp, bytes extraData, bytes32 mixHash, uint64 nonce, uint256 baseFeePerGas) header, bytes proof)",
-        ],
-        [{ header: blockHeader, proof: encodedProof }]
-    );
-
-    return signalProof;
-}
-
 export {
     deployContract,
     getDeployer,
     waitTx,
     getContract,
     saveDeployments,
     getDeployments,
-    getMessageStatusSlot,
-    getSignalSlot,
     decode,
-    MessageStatus,
-    getLatestBlockHeader,
-    getSignalProof,
 };

packages/protocol/test/L1/TaikoL1.integration.test.ts

@@ -0,0 +1,160 @@
+import { expect } from "chai";
+import { BigNumber, ethers as ethersLib } from "ethers";
+import { ethers } from "hardhat";
+import { TaikoL1, TaikoL2 } from "../../typechain";
+import { BlockMetadata } from "../utils/block_metadata";
+import { commitBlock, generateCommitHash } from "../utils/commit";
+import { buildProposeBlockInputs, proposeBlock } from "../utils/propose";
+import { deployTaikoL1 } from "../utils/taikoL1";
+import { deployTaikoL2 } from "../utils/taikoL2";
+
+describe("integration:TaikoL1", function () {
+    let taikoL1: TaikoL1;
+    let taikoL2: TaikoL2;
+    let l2Provider: ethersLib.providers.JsonRpcProvider;
+    let l2Signer: ethersLib.Signer;
+
+    beforeEach(async function () {
+        l2Provider = new ethers.providers.JsonRpcProvider(
+            "http://localhost:28545"
+        );
+
+        l2Signer = await l2Provider.getSigner(
+            (
+                await l2Provider.listAccounts()
+            )[0]
+        );
+
+        taikoL2 = await deployTaikoL2(l2Signer);
+
+        const genesisHash = taikoL2.deployTransaction.blockHash as string;
+
+        taikoL1 = await deployTaikoL1(genesisHash);
+    });
+
+    describe("isCommitValid()", async function () {
+        it("should not be valid", async function () {
+            const block = await l2Provider.getBlock("latest");
+            const commit = generateCommitHash(block);
+
+            const isCommitValid = await taikoL1.isCommitValid(
+                1,
+                1,
+                commit.hash
+            );
+
+            expect(isCommitValid).to.be.eq(false);
+        });
+    });
+
+    describe("getProposedBlock()", function () {
+        it("proposed block does not exist", async function () {
+            const block = await taikoL1.getProposedBlock(123);
+            expect(block[0]).to.be.eq(ethers.constants.HashZero);
+            expect(block[1]).to.be.eq(ethers.constants.AddressZero);
+            expect(block[2]).to.be.eq(BigNumber.from(0));
+        });
+    });
+    describe("commitBlock() -> proposeBlock() integration", async function () {
+        it("should revert with invalid meta", async function () {
+            const block = await l2Provider.getBlock("latest");
+            const { tx, commit } = await commitBlock(taikoL1, block);
+
+            await expect(
+                proposeBlock(
+                    taikoL1,
+                    block,
+                    commit.txListHash,
+                    tx.blockNumber as number,
+                    1,
+                    block.gasLimit
+                )
+            ).to.be.revertedWith("L1:placeholder");
+        });
+
+        it("should revert with invalid gasLimit", async function () {
+            const block = await l2Provider.getBlock("latest");
+            const { tx, commit } = await commitBlock(taikoL1, block);
+
+            // blockMetadata is inputs[0], txListBytes = inputs[1]
+            const config = await taikoL1.getConfig();
+            const gasLimit = config[7];
+            await proposeBlock(
+                taikoL1,
+                block,
+                commit.txListHash,
+                tx.blockNumber as number,
+                0,
+                block.gasLimit
+            );
+
+            await expect(
+                proposeBlock(
+                    taikoL1,
+                    block,
+                    commit.txListHash,
+                    tx.blockNumber as number,
+                    0,
+                    gasLimit.add(1)
+                )
+            ).to.be.revertedWith("L1:gasLimit");
+        });
+
+        it("should revert with invalid extraData", async function () {
+            const block = await l2Provider.getBlock("latest");
+            const { tx, commit } = await commitBlock(taikoL1, block);
+
+            const meta: BlockMetadata = {
+                id: 0,
+                l1Height: 0,
+                l1Hash: ethers.constants.HashZero,
+                beneficiary: block.miner,
+                txListHash: commit.txListHash,
+                mixHash: ethers.constants.HashZero,
+                extraData: ethers.utils.hexlify(ethers.utils.randomBytes(33)), // invalid extradata
+                gasLimit: block.gasLimit,
+                timestamp: 0,
+                commitSlot: 1,
+                commitHeight: tx.blockNumber as number,
+            };
+
+            const inputs = buildProposeBlockInputs(block, meta);
+
+            await expect(taikoL1.proposeBlock(inputs)).to.be.revertedWith(
+                "L1:extraData"
+            );
+        });
+
+        it("should commit and be able to propose", async function () {
+            const block = await l2Provider.getBlock("latest");
+            const { tx, commit } = await commitBlock(taikoL1, block);
+
+            await proposeBlock(
+                taikoL1,
+                block,
+                commit.txListHash,
+                tx.blockNumber as number,
+                0,
+                block.gasLimit
+            );
+
+            const stateVariables = await taikoL1.getStateVariables();
+            const nextBlockId = stateVariables[4];
+            const proposedBlock = await taikoL1.getProposedBlock(
+                nextBlockId.sub(1)
+            );
+
+            expect(proposedBlock[0]).not.to.be.eq(ethers.constants.HashZero);
+            expect(proposedBlock[2]).not.to.be.eq(ethers.constants.AddressZero);
+            expect(proposedBlock[3]).not.to.be.eq(BigNumber.from(0));
+
+            const isCommitValid = await taikoL1.isCommitValid(
+                1,
+                tx.blockNumber as number,
+                commit.hash
+            );
+
+            expect(isCommitValid).to.be.eq(true);
+        });
+    });
+});