@aztec/end-to-end 0.0.0-test.0 → 0.0.1-commit.03f7ef2

package/src/e2e_fees/fees_test.ts

@@ -1,28 +1,26 @@
-import { getSchnorrWallet } from '@aztec/accounts/schnorr';
-import {
-  type AccountWallet,
-  type AztecAddress,
-  type AztecNode,
-  ChainMonitor,
-  CheatCodes,
-  type Logger,
-  type PXE,
-  createLogger,
-  sleep,
-} from '@aztec/aztec.js';
-import { FEE_FUNDING_FOR_TESTER_ACCOUNT } from '@aztec/constants';
-import { type DeployL1ContractsArgs, RollupContract, createL1Clients } from '@aztec/ethereum';
+import type { AztecAddress } from '@aztec/aztec.js/addresses';
+import { type Logger, createLogger } from '@aztec/aztec.js/log';
+import type { AztecNode } from '@aztec/aztec.js/node';
+import { CheatCodes } from '@aztec/aztec/testing';
+import { createExtendedL1Client } from '@aztec/ethereum/client';
+import { RollupContract } from '@aztec/ethereum/contracts';
+import type { DeployAztecL1ContractsArgs } from '@aztec/ethereum/deploy-aztec-l1-contracts';
+import { ChainMonitor } from '@aztec/ethereum/test';
+import { BlockNumber } from '@aztec/foundation/branded-types';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { RollupAbi, TestERC20Abi } from '@aztec/l1-artifacts';
+import { sleep } from '@aztec/foundation/sleep';
+import { TestERC20Abi } from '@aztec/l1-artifacts';
 import { AppSubscriptionContract } from '@aztec/noir-contracts.js/AppSubscription';
-import { CounterContract } from '@aztec/noir-contracts.js/Counter';
 import { FPCContract } from '@aztec/noir-contracts.js/FPC';
 import { FeeJuiceContract } from '@aztec/noir-contracts.js/FeeJuice';
+import { SponsoredFPCContract } from '@aztec/noir-contracts.js/SponsoredFPC';
 import { TokenContract as BananaCoin } from '@aztec/noir-contracts.js/Token';
+import { CounterContract } from '@aztec/noir-test-contracts.js/Counter';
 import { ProtocolContractAddress } from '@aztec/protocol-contracts';
 import { getCanonicalFeeJuice } from '@aztec/protocol-contracts/fee-juice';
-import { computePartialAddress } from '@aztec/stdlib/contract';
 import { GasSettings } from '@aztec/stdlib/gas';
+import type { AztecNodeAdmin } from '@aztec/stdlib/interfaces/client';
+import { TestWallet } from '@aztec/test-wallet/server';
 
 import { getContract } from 'viem';
 
@@ -37,9 +35,9 @@ import { mintTokensToPrivate } from '../fixtures/token_utils.js';
 import {
   type BalancesFn,
   type SetupOptions,
-  ensureAccountsPubliclyDeployed,
+  ensureAccountContractsPublished,
   getBalancesFn,
-  setupCanonicalFeeJuice,
+  setupSponsoredFPC,
 } from '../fixtures/utils.js';
 import { FeeJuicePortalTestingHarnessFactory, type GasBridgingTestHarness } from '../shared/gas_portal_test_harness.js';
 
@@ -51,21 +49,21 @@ const { E2E_DATA_PATH: dataPath } = process.env;
  * PublicDeployAccounts: Deploys the accounts publicly.
  * DeployFeeJuice: Deploys the Fee Juice contract.
  * FPCSetup: Deploys BananaCoin and FPC contracts, and bridges gas from L1.
+ * SponsoredFPCSetup: Deploys Sponsored FPC contract, and bridges gas from L1.
  * FundAlice: Mints private and public bananas to Alice.
  * SetupSubscription: Deploys a counter contract and a subscription contract, and mints Fee Juice to the subscription contract.
  */
 export class FeesTest {
   private snapshotManager: ISnapshotManager;
-  private wallets: AccountWallet[] = [];
+  private accounts: AztecAddress[] = [];
 
   public logger: Logger;
-  public pxe!: PXE;
   public aztecNode!: AztecNode;
+  public aztecNodeAdmin!: AztecNodeAdmin;
   public cheatCodes!: CheatCodes;
 
-  public aliceWallet!: AccountWallet;
+  public wallet!: TestWallet;
   public aliceAddress!: AztecAddress;
-  public bobWallet!: AccountWallet;
   public bobAddress!: AztecAddress;
   public sequencerAddress!: AztecAddress;
   public coinbase!: EthAddress;
@@ -74,9 +72,12 @@ export class FeesTest {
 
   public gasSettings!: GasSettings;
 
+  public rollupContract!: RollupContract;
+
   public feeJuiceContract!: FeeJuiceContract;
   public bananaCoin!: BananaCoin;
   public bananaFPC!: FPCContract;
+  public sponsoredFPC!: SponsoredFPCContract;
   public counterContract!: CounterContract;
   public subscriptionContract!: AppSubscriptionContract;
   public feeJuiceBridgeTestHarness!: GasBridgingTestHarness;
@@ -89,7 +90,7 @@ export class FeesTest {
   public getGasBalanceFn!: BalancesFn;
   public getBananaPublicBalanceFn!: BalancesFn;
   public getBananaPrivateBalanceFn!: BalancesFn;
-  public getProverFee!: (blockNumber: number) => Promise<bigint>;
+  public getProverFee!: (blockNumber: BlockNumber) => Promise<bigint>;
 
   public readonly ALICE_INITIAL_BANANAS = BigInt(1e22);
   public readonly SUBSCRIPTION_AMOUNT = BigInt(1e19);
@@ -98,11 +99,13 @@ export class FeesTest {
   constructor(
     testName: string,
     private numberOfAccounts = 3,
-    setupOptions: Partial<SetupOptions & DeployL1ContractsArgs> = {},
+    setupOptions: Partial<SetupOptions & DeployAztecL1ContractsArgs> = {},
   ) {
     if (!numberOfAccounts) {
       throw new Error('There must be at least 1 initial account.');
     }
+    setupOptions.coinbase ??= EthAddress.random();
+    this.coinbase = setupOptions.coinbase!;
     this.logger = createLogger(`e2e:e2e_fees:${testName}`);
     this.snapshotManager = createSnapshotManager(
       `e2e_fees/${testName}-${numberOfAccounts}`,
@@ -114,16 +117,15 @@ export class FeesTest {
 
   async setup() {
     const context = await this.snapshotManager.setup();
-    await context.aztecNode.setConfig({ feeRecipient: this.sequencerAddress, coinbase: this.coinbase });
 
-    const rollupContract = RollupContract.getFromConfig(context.aztecNodeConfig);
-    this.chainMonitor = new ChainMonitor(rollupContract, this.logger, 200).start();
+    this.rollupContract = RollupContract.getFromConfig(context.aztecNodeConfig);
+    this.chainMonitor = new ChainMonitor(this.rollupContract, context.dateProvider, this.logger, 200).start();
 
     return this;
   }
 
   async teardown() {
-    this.chainMonitor.stop();
+    await this.chainMonitor.stop();
     await this.snapshotManager.teardown();
   }
 
@@ -138,19 +140,41 @@ export class FeesTest {
     }
   }
 
-  async mintAndBridgeFeeJuice(address: AztecAddress, amount: bigint) {
-    const claim = await this.feeJuiceBridgeTestHarness.prepareTokensOnL1(amount, address);
+  async getBlockRewards() {
+    const blockReward = await this.rollupContract.getCheckpointReward();
+    const rewardConfig = await this.rollupContract.getRewardConfig();
+
+    const balance = await this.feeJuiceBridgeTestHarness.getL1FeeJuiceBalance(
+      EthAddress.fromString(rewardConfig.rewardDistributor),
+    );
+
+    const toDistribute = balance > blockReward ? blockReward : balance;
+    const sequencerBlockRewards = (toDistribute * BigInt(rewardConfig.sequencerBps)) / 10000n;
+    const proverBlockRewards = toDistribute - sequencerBlockRewards;
+
+    return { sequencerBlockRewards, proverBlockRewards };
+  }
+
+  async mintAndBridgeFeeJuice(minter: AztecAddress, recipient: AztecAddress) {
+    const claim = await this.feeJuiceBridgeTestHarness.prepareTokensOnL1(recipient);
     const { claimSecret: secret, messageLeafIndex: index } = claim;
-    await this.feeJuiceContract.methods.claim(address, amount, secret, index).send().wait();
+    await this.feeJuiceContract.methods
+      .claim(recipient, claim.claimAmount, secret, index)
+      .send({ from: minter })
+      .wait();
   }
 
   /** Alice mints bananaCoin tokens privately to the target address and redeems them. */
   async mintPrivateBananas(amount: bigint, address: AztecAddress) {
-    const balanceBefore = await this.bananaCoin.methods.balance_of_private(address).simulate();
+    const balanceBefore = await this.bananaCoin.methods
+      .balance_of_private(address)
+      .simulate({ from: this.aliceAddress });
 
-    await mintTokensToPrivate(this.bananaCoin, this.aliceWallet, address, amount);
+    await mintTokensToPrivate(this.bananaCoin, this.aliceAddress, address, amount);
 
-    const balanceAfter = await this.bananaCoin.methods.balance_of_private(address).simulate();
+    const balanceAfter = await this.bananaCoin.methods
+      .balance_of_private(address)
+      .simulate({ from: this.aliceAddress });
     expect(balanceAfter).toEqual(balanceBefore + amount);
   }
 
@@ -165,66 +189,52 @@ export class FeesTest {
     await this.snapshotManager.snapshot(
       'initial_accounts',
       deployAccounts(this.numberOfAccounts, this.logger),
-      async ({ deployedAccounts }, { pxe, aztecNode, aztecNodeConfig }) => {
-        this.pxe = pxe;
+      async ({ deployedAccounts }, { wallet, aztecNode, cheatCodes }) => {
+        this.wallet = wallet;
         this.aztecNode = aztecNode;
+        this.aztecNodeAdmin = aztecNode;
         this.gasSettings = GasSettings.default({ maxFeesPerGas: (await this.aztecNode.getCurrentBaseFees()).mul(2) });
-        this.cheatCodes = await CheatCodes.create(aztecNodeConfig.l1RpcUrls, pxe);
-        this.wallets = await Promise.all(deployedAccounts.map(a => getSchnorrWallet(pxe, a.address, a.signingKey)));
-        this.wallets.forEach((w, i) => this.logger.verbose(`Wallet ${i} address: ${w.getAddress()}`));
-        [this.aliceWallet, this.bobWallet] = this.wallets.slice(0, 2);
-        [this.aliceAddress, this.bobAddress, this.sequencerAddress] = this.wallets.map(w => w.getAddress());
+        this.cheatCodes = cheatCodes;
+        this.accounts = deployedAccounts.map(a => a.address);
+        this.accounts.forEach((a, i) => this.logger.verbose(`Account ${i} address: ${a}`));
+        [this.aliceAddress, this.bobAddress, this.sequencerAddress] = this.accounts.slice(0, 3);
 
         // We set Alice as the FPC admin to avoid the need for deployment of another account.
         this.fpcAdmin = this.aliceAddress;
 
         const canonicalFeeJuice = await getCanonicalFeeJuice();
-        this.feeJuiceContract = await FeeJuiceContract.at(canonicalFeeJuice.address, this.aliceWallet);
-        if (this.numberOfAccounts > 1) {
-          const bobInstance = (await this.bobWallet.getContractMetadata(this.bobAddress)).contractInstance;
-          await this.aliceWallet.registerAccount(deployedAccounts[1].secret, await computePartialAddress(bobInstance!));
-        }
-        this.coinbase = EthAddress.random();
-
-        const { publicClient, walletClient } = createL1Clients(aztecNodeConfig.l1RpcUrls, MNEMONIC);
-        this.feeJuiceBridgeTestHarness = await FeeJuicePortalTestingHarnessFactory.create({
-          aztecNode: aztecNode,
-          pxeService: pxe,
-          publicClient: publicClient,
-          walletClient: walletClient,
-          wallet: this.aliceWallet,
-          logger: this.logger,
-        });
+        this.feeJuiceContract = FeeJuiceContract.at(canonicalFeeJuice.address, this.wallet);
       },
     );
   }
 
   async applyPublicDeployAccountsSnapshot() {
     await this.snapshotManager.snapshot('public_deploy_accounts', () =>
-      ensureAccountsPubliclyDeployed(this.aliceWallet, this.wallets),
+      ensureAccountContractsPublished(this.wallet, this.accounts),
     );
   }
 
   async applySetupFeeJuiceSnapshot() {
     await this.snapshotManager.snapshot(
       'setup_fee_juice',
-      async context => {
-        await setupCanonicalFeeJuice(context.pxe);
-      },
+      async () => {},
       async (_data, context) => {
         this.context = context;
 
-        this.feeJuiceContract = await FeeJuiceContract.at(ProtocolContractAddress.FeeJuice, this.aliceWallet);
+        this.feeJuiceContract = FeeJuiceContract.at(ProtocolContractAddress.FeeJuice, this.wallet);
 
-        this.getGasBalanceFn = getBalancesFn('⛽', this.feeJuiceContract.methods.balance_of_public, this.logger);
+        this.getGasBalanceFn = getBalancesFn(
+          '⛽',
+          this.feeJuiceContract.methods.balance_of_public,
+          this.aliceAddress,
+          this.logger,
+        );
 
-        const { publicClient, walletClient } = createL1Clients(context.aztecNodeConfig.l1RpcUrls, MNEMONIC);
         this.feeJuiceBridgeTestHarness = await FeeJuicePortalTestingHarnessFactory.create({
           aztecNode: context.aztecNode,
-          pxeService: context.pxe,
-          publicClient: publicClient,
-          walletClient: walletClient,
-          wallet: this.aliceWallet,
+          aztecNodeAdmin: context.aztecNode,
+          l1Client: context.deployL1ContractsValues.l1Client,
+          wallet: this.wallet,
           logger: this.logger,
         });
       },
@@ -235,14 +245,28 @@ export class FeesTest {
     await this.snapshotManager.snapshot(
       'deploy_banana_token',
       async () => {
-        const bananaCoin = await BananaCoin.deploy(this.aliceWallet, this.aliceAddress, 'BC', 'BC', 18n)
-          .send()
+        const bananaCoin = await BananaCoin.deploy(this.wallet, this.aliceAddress, 'BC', 'BC', 18n)
+          .send({ from: this.aliceAddress })
           .deployed();
         this.logger.info(`BananaCoin deployed at ${bananaCoin.address}`);
         return { bananaCoinAddress: bananaCoin.address };
       },
-      async ({ bananaCoinAddress }) => {
-        this.bananaCoin = await BananaCoin.at(bananaCoinAddress, this.aliceWallet);
+      ({ bananaCoinAddress }) => {
+        this.bananaCoin = BananaCoin.at(bananaCoinAddress, this.wallet);
+        const logger = this.logger;
+        this.getBananaPublicBalanceFn = getBalancesFn(
+          '🍌.public',
+          this.bananaCoin.methods.balance_of_public,
+          this.aliceAddress,
+          logger,
+        );
+        this.getBananaPrivateBalanceFn = getBalancesFn(
+          '🍌.private',
+          this.bananaCoin.methods.balance_of_private,
+          this.aliceAddress,
+          logger,
+        );
+        return Promise.resolve();
       },
     );
   }
@@ -252,16 +276,16 @@ export class FeesTest {
       'fpc_setup',
       async context => {
         const feeJuiceContract = this.feeJuiceBridgeTestHarness.feeJuice;
-        expect((await context.pxe.getContractMetadata(feeJuiceContract.address)).isContractPubliclyDeployed).toBe(true);
+        expect((await context.wallet.getContractMetadata(feeJuiceContract.address)).isContractPublished).toBe(true);
 
         const bananaCoin = this.bananaCoin;
-        const bananaFPC = await FPCContract.deploy(this.aliceWallet, bananaCoin.address, this.fpcAdmin)
-          .send()
+        const bananaFPC = await FPCContract.deploy(this.wallet, bananaCoin.address, this.fpcAdmin)
+          .send({ from: this.aliceAddress })
           .deployed();
 
         this.logger.info(`BananaPay deployed at ${bananaFPC.address}`);
 
-        await this.feeJuiceBridgeTestHarness.bridgeFromL1ToL2(FEE_FUNDING_FOR_TESTER_ACCOUNT, bananaFPC.address);
+        await this.feeJuiceBridgeTestHarness.bridgeFromL1ToL2(bananaFPC.address, this.aliceAddress);
 
         return {
           bananaFPCAddress: bananaFPC.address,
@@ -270,53 +294,69 @@ export class FeesTest {
           rollupAddress: context.deployL1ContractsValues.l1ContractAddresses.rollupAddress,
         };
       },
-      async (data, context) => {
-        const bananaFPC = await FPCContract.at(data.bananaFPCAddress, this.aliceWallet);
+      (data, context) => {
+        const bananaFPC = FPCContract.at(data.bananaFPCAddress, this.wallet);
         this.bananaFPC = bananaFPC;
 
-        const logger = this.logger;
-        this.getBananaPublicBalanceFn = getBalancesFn('🍌.public', this.bananaCoin.methods.balance_of_public, logger);
-        this.getBananaPrivateBalanceFn = getBalancesFn(
-          '🍌.private',
-          this.bananaCoin.methods.balance_of_private,
-          logger,
-        );
-
         this.getCoinbaseBalance = async () => {
-          const { walletClient } = createL1Clients(context.aztecNodeConfig.l1RpcUrls, MNEMONIC);
+          const l1Client = createExtendedL1Client(context.aztecNodeConfig.l1RpcUrls, MNEMONIC);
           const gasL1 = getContract({
             address: data.l1FeeJuiceAddress.toString(),
             abi: TestERC20Abi,
-            client: walletClient,
+            client: l1Client,
           });
           return await gasL1.read.balanceOf([this.coinbase.toString()]);
         };
 
         this.getCoinbaseSequencerRewards = async () => {
-          const { walletClient } = createL1Clients(context.aztecNodeConfig.l1RpcUrls, MNEMONIC);
-          const rollup = getContract({
-            address: data.rollupAddress.toString(),
-            abi: RollupAbi,
-            client: walletClient,
-          });
-
-          return await rollup.read.getSequencerRewards([this.coinbase.toString()]);
+          return await this.rollupContract.getSequencerRewards(this.coinbase);
         };
 
-        this.getProverFee = async (blockNumber: number) => {
-          const { walletClient } = createL1Clients(context.aztecNodeConfig.l1RpcUrls, MNEMONIC);
-          const rollup = getContract({
-            address: data.rollupAddress.toString(),
-            abi: RollupAbi,
-            client: walletClient,
-          });
+        this.getProverFee = async (blockNumber: BlockNumber) => {
+          const block = await this.aztecNode.getBlock(blockNumber);
+
+          // @todo @lherskind As we deal with #13601
+          // Right now the value is from `FeeLib.sol`
+          const L1_GAS_PER_EPOCH_VERIFIED = 1000000n;
 
-          const provingCostPerMana = await rollup.read.getProvingCostPerManaInFeeAsset();
+          // We round up
+          const mulDiv = (a: bigint, b: bigint, c: bigint) => (a * b) / c + ((a * b) % c > 0n ? 1n : 0n);
+
+          const { baseFee } = await this.rollupContract.getL1FeesAt(block!.header.globalVariables.timestamp);
+          const proverCost =
+            mulDiv(
+              mulDiv(L1_GAS_PER_EPOCH_VERIFIED, baseFee, await this.rollupContract.getEpochDuration()),
+              1n,
+              await this.rollupContract.getManaTarget(),
+            ) + (await this.rollupContract.getProvingCostPerMana());
+
+          const price = await this.rollupContract.getFeeAssetPerEth();
 
-          const block = await this.pxe.getBlock(blockNumber);
           const mana = block!.header.totalManaUsed.toBigInt();
-          return mana * provingCostPerMana;
+          return mulDiv(mana * proverCost, price, 10n ** 9n);
         };
+        return Promise.resolve();
+      },
+    );
+  }
+
+  public async applySponsoredFPCSetupSnapshot() {
+    await this.snapshotManager.snapshot(
+      'sponsored_fpc_setup',
+      async context => {
+        const feeJuiceContract = this.feeJuiceBridgeTestHarness.feeJuice;
+        expect((await context.wallet.getContractMetadata(feeJuiceContract.address)).isContractPublished).toBe(true);
+
+        const sponsoredFPC = await setupSponsoredFPC(this.wallet);
+        this.logger.info(`SponsoredFPC at ${sponsoredFPC.address}`);
+
+        return {
+          sponsoredFPCAddress: sponsoredFPC.address,
+        };
+      },
+      data => {
+        this.sponsoredFPC = SponsoredFPCContract.at(data.sponsoredFPCAddress, this.wallet);
+        return Promise.resolve();
       },
     );
   }
@@ -326,7 +366,10 @@ export class FeesTest {
       'fund_alice',
       async () => {
         await this.mintPrivateBananas(this.ALICE_INITIAL_BANANAS, this.aliceAddress);
-        await this.bananaCoin.methods.mint_to_public(this.aliceAddress, this.ALICE_INITIAL_BANANAS).send().wait();
+        await this.bananaCoin.methods
+          .mint_to_public(this.aliceAddress, this.ALICE_INITIAL_BANANAS)
+          .send({ from: this.aliceAddress })
+          .wait();
       },
       () => Promise.resolve(),
     );
@@ -341,37 +384,4 @@ export class FeesTest {
       () => Promise.resolve(),
     );
   }
-
-  public async applySetupSubscription() {
-    await this.snapshotManager.snapshot(
-      'setup_subscription',
-      async () => {
-        const counterContract = await CounterContract.deploy(this.bobWallet, 0, this.bobAddress).send().deployed();
-
-        // Deploy subscription contract, that allows subscriptions for SUBSCRIPTION_AMOUNT of bananas
-        const subscriptionContract = await AppSubscriptionContract.deploy(
-          this.bobWallet,
-          counterContract.address,
-          this.bobAddress,
-          this.bananaCoin.address,
-          this.SUBSCRIPTION_AMOUNT,
-          this.APP_SPONSORED_TX_GAS_LIMIT,
-        )
-          .send()
-          .deployed();
-
-        // Mint some Fee Juice to the subscription contract
-        // Could also use bridgeFromL1ToL2 from the harness, but this is more direct
-        await this.mintAndBridgeFeeJuice(subscriptionContract.address, FEE_FUNDING_FOR_TESTER_ACCOUNT);
-        return {
-          counterContractAddress: counterContract.address,
-          subscriptionContractAddress: subscriptionContract.address,
-        };
-      },
-      async ({ counterContractAddress, subscriptionContractAddress }) => {
-        this.counterContract = await CounterContract.at(counterContractAddress, this.bobWallet);
-        this.subscriptionContract = await AppSubscriptionContract.at(subscriptionContractAddress, this.bobWallet);
-      },
-    );
-  }
 }

package/src/e2e_l1_publisher/write_json.ts

@@ -0,0 +1,77 @@
+import { AztecAddress } from '@aztec/aztec.js/addresses';
+import type { L2Block } from '@aztec/aztec.js/block';
+import { Fr } from '@aztec/aztec.js/fields';
+import { BatchedBlob, Blob, getEthBlobEvaluationInputs, getPrefixedEthBlobCommitments } from '@aztec/blob-lib';
+import { EthAddress } from '@aztec/foundation/eth-address';
+
+import { writeFile } from 'fs/promises';
+
+const AZTEC_GENERATE_TEST_DATA = !!process.env.AZTEC_GENERATE_TEST_DATA;
+
+/**
+ * Creates a json object that can be used to test the solidity contract.
+ * The json object must be put into
+ */
+export async function writeJson(
+  fileName: string,
+  block: L2Block,
+  l1ToL2Content: Fr[],
+  blobs: Blob[],
+  batchedBlob: BatchedBlob,
+  recipientAddress: AztecAddress,
+  deployerAddress: `0x${string}`,
+): Promise<void> {
+  if (!AZTEC_GENERATE_TEST_DATA) {
+    return;
+  }
+  // Path relative to the package.json in the end-to-end folder
+  const path = `../../l1-contracts/test/fixtures/${fileName}.json`;
+
+  const asHex = (value: Fr | Buffer | EthAddress | AztecAddress, size = 64) => {
+    const buffer = Buffer.isBuffer(value) ? value : value.toBuffer();
+    return `0x${buffer.toString('hex').padStart(size, '0')}`;
+  };
+
+  const jsonObject = {
+    populate: {
+      l1ToL2Content: l1ToL2Content.map(value => asHex(value)),
+      recipient: asHex(recipientAddress.toField()),
+      sender: deployerAddress,
+    },
+    messages: {
+      l2ToL1Messages: block.body.txEffects.flatMap(txEffect => txEffect.l2ToL1Msgs).map(value => asHex(value)),
+    },
+    checkpoint: {
+      // The json formatting in forge is a bit brittle, so we convert Fr to a number in the few values below.
+      // This should not be a problem for testing as long as the values are not larger than u32.
+      archive: asHex(block.archive.root),
+      blobCommitments: getPrefixedEthBlobCommitments(blobs),
+      batchedBlobInputs: getEthBlobEvaluationInputs(batchedBlob),
+      checkpointNumber: block.number,
+      body: `0x${block.body.toBuffer().toString('hex')}`,
+      header: {
+        lastArchiveRoot: asHex(block.header.lastArchive.root),
+        blockHeadersHash: asHex(block.header.blockHeadersHash),
+        contentCommitment: {
+          blobsHash: asHex(block.header.contentCommitment.blobsHash),
+          inHash: asHex(block.header.contentCommitment.inHash),
+          outHash: asHex(block.header.contentCommitment.outHash),
+        },
+        slotNumber: Number(block.header.globalVariables.slotNumber),
+        timestamp: Number(block.header.globalVariables.timestamp),
+        coinbase: asHex(block.header.globalVariables.coinbase, 40),
+        feeRecipient: asHex(block.header.globalVariables.feeRecipient),
+        gasFees: {
+          feePerDaGas: Number(block.header.globalVariables.gasFees.feePerDaGas),
+          feePerL2Gas: Number(block.header.globalVariables.gasFees.feePerL2Gas),
+        },
+        totalManaUsed: block.header.totalManaUsed.toNumber(),
+      },
+      headerHash: asHex(block.getCheckpointHeader().hash()),
+      numTxs: block.body.txEffects.length,
+    },
+  };
+
+  const output = JSON.stringify(jsonObject, null, 2);
+  await writeFile(path, output, 'utf8');
+}