DecoderBase.sol

// SPDX-License-Identifier: Apache-2.0
// Copyright 2024 Aztec Labs.
pragma solidity >=0.8.27;

import {TestBase} from "../base/Base.sol";

import {Timestamp, Slot} from "@aztec/core/libraries/TimeLib.sol";
import {ProposedHeader, GasFees} from "@aztec/core/libraries/rollup/ProposedHeaderLib.sol";
import {ProposedHeaderLib} from "@aztec/core/libraries/rollup/ProposedHeaderLib.sol";

// Many of the structs in here match what you see in `header` but with very important exceptions!
// The order of variables is sorted alphabetically in the structs in here to work with the
// JSON cheatcodes.

contract DecoderBase is TestBase {
  using ProposedHeaderLib for ProposedHeader;

  // When I had data and messages as one combined struct it failed, but I can have this top-layer and it works :shrug:
  // Note: Members of the struct (and substructs) have to be in ALPHABETICAL order!
  struct Full {
    Data checkpoint;
    Messages messages;
    Populate populate;
  }

  struct AlphabeticalFull {
    AlphabeticalData checkpoint;
    Messages messages;
    Populate populate;
  }

  struct Populate {
    bytes32[] l1ToL2Content;
    bytes32 recipient;
    address sender;
  }

  struct Messages {
    bytes32[] l2ToL1Messages;
  }

  struct AlphabeticalHeader {
    uint256 accumulatedFees;
    bytes32 blobsHash;
    bytes32 blockHeadersHash;
    address coinbase;
    bytes32 feeRecipient;
    GasFees gasFees;
    bytes32 inboxRollingHash;
    bytes32 lastArchiveRoot;
    bytes32 outHash;
    uint256 slotNumber;
    uint256 timestamp;
    uint256 totalManaUsed;
  }

  struct Data {
    bytes32 archive;
    // Note: batchedBlobInputs is usually per epoch, rather than per checkpoint. For testing, these batchedBlobInputs
    // assume that an epoch contains blobs including and up to the 'current' checkpoint.
    // e.g. mixed_checkpoint_2's batchedBlobInputs assumes that the epoch consists of 2 checkpoints, mixed_checkpoint_1
    // and mixed_checkpoint_2, and their blobs.
    // e.g. mixed_checkpoint_1's batchedBlobInputs assumes the epoch contains only mixed_checkpoint_1 and its blob(s).
    bytes batchedBlobInputs; // EVM point evaluation precompile inputs for verifying an epoch's batch of blobs
    bytes blobCommitments; // [numBlobs, ...blobCommitments], used in proposing checkpoints
    uint256 checkpointNumber;
    bytes body;
    ProposedHeader header;
    bytes32 headerHash;
    uint32 numTxs;
  }

  struct AlphabeticalData {
    bytes32 archive;
    bytes batchedBlobInputs;
    bytes blobCommitments;
    bytes body;
    uint256 checkpointNumber;
    AlphabeticalHeader header;
    bytes32 headerHash;
    uint32 numTxs;
  }

  function load(string memory name) internal view returns (Full memory) {
    string memory root = vm.projectRoot();
    string memory path = string.concat(root, "/test/fixtures/", name, ".json");
    string memory json = vm.readFile(path);
    bytes memory jsonBytes = vm.parseJson(json);
    AlphabeticalFull memory full = abi.decode(jsonBytes, (AlphabeticalFull));
    return fromAlphabeticalToNormal(full);
  }

  // Decode does not support the custom types
  function fromAlphabeticalToNormal(AlphabeticalFull memory full) internal pure returns (Full memory) {
    Full memory result = Full({
      checkpoint: Data({
        archive: full.checkpoint.archive,
        blobCommitments: full.checkpoint.blobCommitments,
        batchedBlobInputs: full.checkpoint.batchedBlobInputs,
        checkpointNumber: full.checkpoint.checkpointNumber,
        body: full.checkpoint.body,
        header: ProposedHeader({
          lastArchiveRoot: full.checkpoint.header.lastArchiveRoot,
          blockHeadersHash: full.checkpoint.header.blockHeadersHash,
          blobsHash: full.checkpoint.header.blobsHash,
          inboxRollingHash: full.checkpoint.header.inboxRollingHash,
          outHash: full.checkpoint.header.outHash,
          slotNumber: Slot.wrap(full.checkpoint.header.slotNumber),
          timestamp: Timestamp.wrap(full.checkpoint.header.timestamp),
          coinbase: full.checkpoint.header.coinbase,
          feeRecipient: full.checkpoint.header.feeRecipient,
          gasFees: full.checkpoint.header.gasFees,
          totalManaUsed: full.checkpoint.header.totalManaUsed,
          accumulatedFees: full.checkpoint.header.accumulatedFees
        }),
        headerHash: full.checkpoint.headerHash,
        numTxs: full.checkpoint.numTxs
      }),
      messages: full.messages,
      populate: full.populate
    });

    assertEq(result.checkpoint.headerHash, result.checkpoint.header.hash(), "headerHash mismatch when loading");

    return result;
  }

  function max(uint256 a, uint256 b) internal pure returns (uint256) {
    return a > b ? a : b;
  }
}