feat(protocol): prepare ontake fork to support new params & metadata

packages/protocol/contracts/L1/ITaikoL1.sol

@@ -19,6 +19,18 @@ interface ITaikoL1 {
  payable
  returns (TaikoData.BlockMetadata memory meta_, TaikoData.EthDeposit[] memory deposits_);
 
+ /// @notice Proposes a Taiko L2 block (version 2)
+ /// @param _params Block parameters, currently an encoded BlockParams object.
+ /// @param _txList txList data if calldata is used for DA.
+ /// @return meta_ The metadata of the proposed L2 block.
+ function proposeBlock2(
+ bytes calldata _params,
+ bytes calldata _txList
+ )
+ external
+ payable
+ returns (TaikoData.BlockMetadata2 memory meta_);
+
  /// @notice Proves or contests a block transition.
  /// @param _blockId The index of the block to prove. This is also used to
  /// select the right implementation version.

packages/protocol/contracts/L1/TaikoData.sol

@@ -35,7 +35,7 @@ library TaikoData {
  // ---------------------------------------------------------------------
  // The number of L2 blocks between each L2-to-L1 state root sync.
  uint8 stateRootSyncInternal;
- bool checkEOAForCalldataDA;
+ uint64 fujiForkHeight;
  }
 
  /// @dev Struct representing prover fees per given tier
@@ -63,7 +63,15 @@ library TaikoData {
  bytes32 extraData;
  bytes32 parentMetaHash;
  HookCall[] hookCalls; // DEPRECATED, value ignored.
- bytes signature;
+ bytes signature; // DEPRECATED, value ignored.
+ }
+
+ struct BlockParams2 {
+ address coinbase;
+ bytes32 extraData;
+ bytes32 parentMetaHash;
+ uint64 anchorBlockId; // NEW
+ uint64 timestamp; // NEW
  }
 
  /// @dev Struct containing data only required for proving a block
@@ -87,6 +95,25 @@ library TaikoData {
  address sender; // a.k.a proposer
  }
 
+ struct BlockMetadata2 {
+ bytes32 anchorBlockHash; // `_l1BlockHash` in TaikoL2's anchor tx.
+ bytes32 difficulty;
+ bytes32 blobHash;
+ bytes32 extraData;
+ address coinbase;
+ uint64 id;
+ uint32 gasLimit;
+ uint64 timestamp;
+ uint64 anchorBlockId; // `_l1BlockId` in TaikoL2's anchor tx.
+ uint16 minTier;
+ bool blobUsed;
+ bytes32 parentMetaHash;
+ address proposer;
+ uint96 livenessBond;
+ uint64 proposedAt; // timestamp
+ uint64 proposedIn; // L1 block number, required/used by node/client.
+ }
+
  /// @dev Struct representing transition to be proven.
  struct Transition {
  bytes32 parentHash;
@@ -117,8 +144,14 @@ library TaikoData {
  address assignedProver; // slot 2
  uint96 livenessBond;
  uint64 blockId; // slot 3
- uint64 proposedAt; // timestamp
- uint64 proposedIn; // L1 block number, required/used by node/client.
+ // Before the fork, this field is the L1 timestamp when this block is proposed.
+ // After the fork, this is the timestamp of the L2 block.
+ // In a later fork, we an rename this field to `timestamp`.
+ uint64 proposedAt;
+ // Before the fork, this field is the L1 block number where this block is proposed.
+ // After the fork, this is the L1 block number input for the anchor transaction.
+ // In a later fork, we an rename this field to `anchorBlockId`.
+ uint64 proposedIn;
  uint32 nextTransitionId;
  // The ID of the transaction that is used to verify this block. However, if
  // this block is not verified as the last block in a batch, verifiedTransitionId

packages/protocol/contracts/L1/TaikoErrors.sol

@@ -16,13 +16,16 @@ abstract contract TaikoErrors {
  error L1_BLOB_NOT_FOUND();
  error L1_BLOCK_MISMATCH();
  error L1_CANNOT_CONTEST();
+ error L1_FORK_ERROR();
  error L1_INVALID_BLOCK_ID();
  error L1_INVALID_CONFIG();
  error L1_INVALID_GENESIS_HASH();
+ error L1_INVALID_ANCHOR_BLOCK();
  error L1_INVALID_PARAM();
  error L1_INVALID_PAUSE_STATUS();
- error L1_INVALID_SIG();
+ error L1_INVALID_PROPOSER();
  error L1_INVALID_TIER();
+ error L1_INVALID_TIMESTAMP();
  error L1_INVALID_TRANSITION();
  error L1_LIVENESS_BOND_NOT_RECEIVED();
  error L1_NOT_ASSIGNED_PROVER();

packages/protocol/contracts/L1/TaikoEvents.sol

@@ -26,6 +26,11 @@ abstract contract TaikoEvents {
  TaikoData.EthDeposit[] depositsProcessed
  );
 
+ /// @notice Emitted when a block is proposed.
+ /// @param blockId The ID of the proposed block.
+ /// @param meta The metadata of the proposed block.
+ event BlockProposed2(uint256 indexed blockId, TaikoData.BlockMetadata2 meta);
+
  /// @notice Emitted when a block's txList is in the calldata.
  /// @param blockId The ID of the proposed block.
  /// @param txList The txList.
@@ -65,6 +70,15 @@ abstract contract TaikoEvents {
  uint16 tier
  );
 
+ event TransitionProved2(
+ uint256 indexed blockId,
+ TaikoData.Transition tran,
+ address prover,
+ uint96 validityBond,
+ uint16 tier,
+ uint64 proposedIn
+ );
+
  /// @dev Emitted when a block transition is contested.
  /// @param blockId The ID of the proven block.
  /// @param tran The verified transition.
@@ -79,6 +93,15 @@ abstract contract TaikoEvents {
  uint16 tier
  );
 
+ event TransitionContested2(
+ uint256 indexed blockId,
+ TaikoData.Transition tran,
+ address contester,
+ uint96 contestBond,
+ uint16 tier,
+ uint64 proposedIn
+ );
+
  /// @dev Emitted when proving has been paused
  /// @param paused True if paused, false if unpaused.
  event ProvingPaused(bool paused);

packages/protocol/contracts/L1/TaikoL1.sol

@@ -2,6 +2,7 @@
 pragma solidity 0.8.24;
 
 import "../common/EssentialContract.sol";
+import "./libs/LibData.sol";
 import "./libs/LibProposing.sol";
 import "./libs/LibProving.sol";
 import "./libs/LibVerifying.sol";
@@ -81,7 +82,30 @@ contract TaikoL1 is EssentialContract, ITaikoL1, TaikoEvents, TaikoErrors {
  TaikoData.Config memory config = getConfig();
  TaikoToken tko = TaikoToken(resolve(LibStrings.B_TAIKO_TOKEN, false));
 
- (meta_, deposits_) = LibProposing.proposeBlock(state, tko, config, this, _params, _txList);
+ TaikoData.BlockMetadata2 memory meta2;
+ (meta2, deposits_) = LibProposing.proposeBlock(state, tko, config, this, _params, _txList);
+
+ if (meta2.id >= config.fujiForkHeight) revert L1_FORK_ERROR();
+
+ if (LibUtils.shouldVerifyBlocks(config, meta_.id, true) && !state.slotB.provingPaused) {
+ LibVerifying.verifyBlocks(state, tko, config, this, config.maxBlocksToVerify);
+ }
+ meta_ = LibData.metadataV2toV1(meta2);
+ }
+
+ function proposeBlock2(
+ bytes calldata _params,
+ bytes calldata _txList
+ )
+ external
+ payable
+ returns (TaikoData.BlockMetadata2 memory meta_)
+ {
+ TaikoData.Config memory config = getConfig();
+ TaikoToken tko = TaikoToken(resolve(LibStrings.B_TAIKO_TOKEN, false));
+
+ (meta_,) = LibProposing.proposeBlock(state, tko, config, this, _params, _txList);
+ if (meta_.id < config.fujiForkHeight) revert L1_FORK_ERROR();
 
  if (LibUtils.shouldVerifyBlocks(config, meta_.id, true) && !state.slotB.provingPaused) {
  LibVerifying.verifyBlocks(state, tko, config, this, config.maxBlocksToVerify);
@@ -234,7 +258,7 @@ contract TaikoL1 is EssentialContract, ITaikoL1, TaikoEvents, TaikoErrors {
  blockMaxGasLimit: 240_000_000,
  livenessBond: 125e18, // 125 Taiko token
  stateRootSyncInternal: 16,
- checkEOAForCalldataDA: true
+ fujiForkHeight: 324_512 * 2
  });
  }
 

packages/protocol/contracts/L1/access/IProposerAccess.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.24;
+
+/// @title IProposerAccess
+/// @dev An interface to check if a proposer is eligible to propose blocks in a specific Ethereum
+/// block.
+/// @custom:security-contact [email protected]
+interface IProposerAccess {
+ /// @notice Checks if a proposer can propose block in the current Ethereum block.
+ /// @param _proposer The proposer.
+ /// @return true if the proposer can propose blocks, false otherwise.
+ function isProposerEligible(address _proposer) external view returns (bool);
+}

packages/protocol/contracts/L1/access/ProposerRegistry.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.24;
+
+import "../../common/EssentialContract.sol";
+import "./IProposerAccess.sol";
+
+/// @title ProposerRegistry
+/// A dummy implementation that only whitelist some trusted addresses. A real
+/// implementation would only allow a single proposer address to propose a block
+/// using some selection mechanism.
+/// @custom:security-contact [email protected]
+contract ProposerRegistry is EssentialContract, IProposerAccess {
+ /// @dev Emitted when the status of a proposer is updated.
+ /// @param proposer The address of the proposer whose state has updated.
+ /// @param enabled If the proposer is now enabled or not.
+ event ProposerUpdated(address indexed proposer, bool enabled);
+
+ error PR_INVALID_PARAM();
+
+ /// @notice Whitelisted proposers
+ mapping(address proposer => bool enabled) public proposers;
+
+ uint256[49] private __gap;
+
+ /// @notice Initializes the contract with the provided address manager.
+ /// @param _owner The address of the owner.
+ function init(address _owner) external initializer {
+ __Essential_init(_owner);
+ }
+
+ /// @notice Register or unregister proposers.
+ /// @param _proposers The list of proposers
+ /// @param _enabled The corresponding list of the new status of the proposers
+ function registerProposers(
+ address[] memory _proposers,
+ bool[] memory _enabled
+ )
+ external
+ onlyOwner
+ {
+ if (_proposers.length != _enabled.length) revert PR_INVALID_PARAM();
+ for (uint256 i = 0; i < _proposers.length; ++i) {
+ proposers[_proposers[i]] = _enabled[i];
+ emit ProposerUpdated(_proposers[i], _enabled[i]);
+ }
+ }
+
+ /// @inheritdoc IProposerAccess
+ function isProposerEligible(address _proposer) external view returns (bool) {
+ return proposers[_proposer];
+ }
+}

packages/protocol/contracts/L1/libs/LibData.sol

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.24;
+
+import "../TaikoData.sol";
+
+/// @title LibData
+/// @notice A library that offers helper functions.
+/// @custom:security-contact [email protected]
+library LibData {
+ // = keccak256(abi.encode(new TaikoData.EthDeposit[](0)))
+ bytes32 internal constant EMPTY_ETH_DEPOSIT_HASH =
+ 0x569e75fc77c1a856f6daaf9e69d8a9566ca34aa47f9133711ce065a571af0cfd;
+
+ function paramV1toV2(TaikoData.BlockParams memory _v1)
+ internal
+ pure
+ returns (TaikoData.BlockParams2 memory)
+ {
+ return TaikoData.BlockParams2({
+ coinbase: _v1.coinbase,
+ extraData: _v1.extraData,
+ parentMetaHash: _v1.parentMetaHash,
+ anchorBlockId: 0,
+ timestamp: 0
+ });
+ }
+
+ function metadataV2toV1(TaikoData.BlockMetadata2 memory _v2)
+ internal
+ pure
+ returns (TaikoData.BlockMetadata memory)
+ {
+ return TaikoData.BlockMetadata({
+ l1Hash: _v2.anchorBlockHash,
+ difficulty: _v2.difficulty,
+ blobHash: _v2.blobHash,
+ extraData: _v2.extraData,
+ depositsHash: EMPTY_ETH_DEPOSIT_HASH,
+ coinbase: _v2.coinbase,
+ id: _v2.id,
+ gasLimit: _v2.gasLimit,
+ timestamp: _v2.timestamp,
+ l1Height: _v2.anchorBlockId,
+ minTier: _v2.minTier,
+ blobUsed: _v2.blobUsed,
+ parentMetaHash: _v2.parentMetaHash,
+ sender: _v2.proposer
+ });
+ }
+
+ function metadataV1toV2(
+ TaikoData.BlockMetadata memory _v1,
+ uint96 _livenessBond
+ )
+ internal
+ pure
+ returns (TaikoData.BlockMetadata2 memory)
+ {
+ return TaikoData.BlockMetadata2({
+ anchorBlockHash: _v1.l1Hash,
+ difficulty: _v1.difficulty,
+ blobHash: _v1.blobHash,
+ extraData: _v1.extraData,
+ coinbase: _v1.coinbase,
+ id: _v1.id,
+ gasLimit: _v1.gasLimit,
+ timestamp: _v1.timestamp,
+ anchorBlockId: _v1.l1Height,
+ minTier: _v1.minTier,
+ blobUsed: _v1.blobUsed,
+ parentMetaHash: _v1.parentMetaHash,
+ proposer: _v1.sender,
+ livenessBond: _livenessBond,
+ proposedAt: 0,
+ proposedIn: 0
+ });
+ }
+
+ function hashMetadata(
+ bool postFork,
+ TaikoData.BlockMetadata2 memory _meta
+ )
+ internal
+ pure
+ returns (bytes32)
+ {
+ return postFork
+ ? keccak256(abi.encode(_meta)) //
+ : keccak256(abi.encode(metadataV2toV1(_meta)));
+ }
+}