@aztec/stdlib 3.0.0-canary.a9708bd → 3.0.0-manual.20251030

package/src/messaging/l2_to_l1_membership.ts

@@ -1,18 +1,5 @@
 import { Fr } from '@aztec/foundation/fields';
-import {
-  SiblingPath,
-  UnbalancedMerkleTreeCalculator,
-  computeUnbalancedMerkleTreeRoot,
-  findLeafLevelAndIndex,
-  getMaxUnbalancedTreeDepth,
-} from '@aztec/foundation/trees';
-
-async function createOutHashTree(messages: Fr[]) {
-  const messageSubtreeHeight = getMaxUnbalancedTreeDepth(messages.length);
-  const calculator = UnbalancedMerkleTreeCalculator.create(messageSubtreeHeight);
-  await calculator.appendLeaves(messages.map(msg => msg.toBuffer()));
-  return calculator;
-}
+import { SiblingPath, UnbalancedMerkleTreeCalculator, computeUnbalancedMerkleTreeRoot } from '@aztec/foundation/trees';
 
 export interface MessageRetrieval {
   getL2ToL1Messages(l2BlockNumber: number): Promise<Fr[][] | undefined>;
@@ -37,10 +24,12 @@ export async function computeL2ToL1MembershipWitness(
   return computeL2ToL1MembershipWitnessFromMessagesForAllTxs(messagesForAllTxs, message);
 }
 
-export async function computeL2ToL1MembershipWitnessFromMessagesForAllTxs(
+// TODO: Allow to specify the message to consume by its index or by an offset, in case there are multiple messages with
+// the same value.
+export function computeL2ToL1MembershipWitnessFromMessagesForAllTxs(
   messagesForAllTxs: Fr[][],
   message: Fr,
-): Promise<L2ToL1MembershipWitness> {
+): L2ToL1MembershipWitness {
   // Find index of message in subtree and index of tx in a block.
   let messageIndexInTx = -1;
   const txIndex = messagesForAllTxs.findIndex(messages => {
@@ -54,9 +43,9 @@ export async function computeL2ToL1MembershipWitnessFromMessagesForAllTxs(
 
   // Get the txOutHash and the sibling path of the message in the tx subtree.
   const txMessages = messagesForAllTxs[txIndex];
-  const txOutHashTree = await createOutHashTree(txMessages);
+  const txOutHashTree = UnbalancedMerkleTreeCalculator.create(txMessages.map(msg => msg.toBuffer()));
   const txOutHash = txOutHashTree.getRoot();
-  const messagePathInSubtree = await txOutHashTree.getSiblingPath(message);
+  const messagePathInSubtree = txOutHashTree.getSiblingPath(message.toBuffer());
 
   // Calculate txOutHash for all txs.
   const txSubtreeRoots = messagesForAllTxs.map((messages, i) => {
@@ -74,21 +63,26 @@ export async function computeL2ToL1MembershipWitnessFromMessagesForAllTxs(
   });
 
   // Construct the top tree.
-  // The leaves of this tree are the txOutHashes.
-  // The root of this tree is the out_hash calculated in the circuit.
-  const topTree = await createOutHashTree(txSubtreeRoots);
+  // The leaves of this tree are the `txOutHashes`.
+  // The root of this tree should match the `out_hash` calculated in the circuits. Zero hashes are compressed to reduce
+  // cost if the non-zero leaves result in a shorter path.
+  const valueToCompress = Buffer.alloc(32);
+  const topTree = UnbalancedMerkleTreeCalculator.create(
+    txSubtreeRoots.map(root => root.toBuffer()),
+    valueToCompress,
+  );
   const root = Fr.fromBuffer(topTree.getRoot());
 
   // Compute the combined sibling path by appending the tx subtree path to the top tree path.
-  const txPathInTopTree = await topTree.getSiblingPath(txOutHash);
+  const txPathInTopTree = topTree.getSiblingPath(txOutHash);
   const combinedPath = messagePathInSubtree.toBufferArray().concat(txPathInTopTree.toBufferArray());
 
   // Compute the combined index.
   // It is the index of the message in the balanced tree at its current height.
-  const txLeafPosition = findLeafLevelAndIndex(messagesForAllTxs.length, txIndex);
-  const messageLeafPosition = findLeafLevelAndIndex(txMessages.length, messageIndexInTx);
-  const numLeavesInLeftSubtrees = txLeafPosition.indexAtLevel * (1 << messageLeafPosition.level);
-  const combinedIndex = numLeavesInLeftSubtrees + messageLeafPosition.indexAtLevel;
+  const txLeafIndexAtLevel = topTree.getLeafLocation(txIndex).index;
+  const messageLeafPosition = txOutHashTree.getLeafLocation(messageIndexInTx);
+  const numLeavesInLeftSubtrees = txLeafIndexAtLevel * (1 << messageLeafPosition.level);
+  const combinedIndex = numLeavesInLeftSubtrees + messageLeafPosition.index;
 
   return {
     root,

package/src/noir/index.ts

@@ -64,6 +64,8 @@ interface NoirFunctionEntry {
 export interface NoirCompiledContract {
   /** The name of the contract. */
   name: string;
+  /** Is the contract's public bytecode transpiled? */
+  transpiled?: boolean;
   /** The functions of the contract. */
   functions: NoirFunctionEntry[];
   /** The events of the contract */
@@ -87,6 +89,15 @@ export interface NoirCompiledCircuit {
   abi: NoirFunctionAbi;
   /** The bytecode of the circuit in base64. */
   bytecode: string;
+  /** The verification key of the circuit. */
+  verificationKey: {
+    /** hex-encoded binary */
+    bytes: string;
+    /** list of hex-encoded fields */
+    fields: string[];
+    /** The hex-encoded hash. */
+    hash: string;
+  };
   /** The debug information, compressed and base64 encoded. */
   debug_symbols: string;
   /** The map of file ID to the source code and path of the file. */

package/src/note/index.ts

@@ -1,5 +1,5 @@
 export * from './comparator.js';
-export * from './extended_note.js';
+export * from './unique_note.js';
 export * from './notes_filter.js';
 export * from './note_status.js';
 export * from './note.js';

package/src/note/notes_filter.ts

@@ -4,7 +4,6 @@ import { z } from 'zod';
 
 import type { AztecAddress } from '../aztec-address/index.js';
 import { type ZodFor, schemas } from '../schemas/index.js';
-import { TxHash } from '../tx/tx_hash.js';
 import { NoteStatus } from './note_status.js';
 
 /**
@@ -17,12 +16,8 @@ export type NotesFilter = {
    * @remarks Providing a contract address is required as we need that information to trigger private state sync.
    */
   contractAddress: AztecAddress;
-  /** Hash of a transaction from which to fetch the notes. */
-  txHash?: TxHash;
   /** The specific storage location of the note on the contract. */
   storageSlot?: Fr;
-  /** The recipient of the note (whose public key was used to encrypt the note). */
-  recipient?: AztecAddress;
   /** The status of the note. Defaults to 'ACTIVE'. */
   status?: NoteStatus;
   /** The siloed nullifier for the note. */
@@ -33,9 +28,7 @@ export type NotesFilter = {
 
 export const NotesFilterSchema: ZodFor<NotesFilter> = z.object({
   contractAddress: schemas.AztecAddress,
-  txHash: TxHash.schema.optional(),
   storageSlot: schemas.Fr.optional(),
-  recipient: schemas.AztecAddress.optional(),
   status: z.nativeEnum(NoteStatus).optional(),
   siloedNullifier: schemas.Fr.optional(),
   scopes: z.array(schemas.AztecAddress).optional(),

package/src/note/{extended_note.ts → unique_note.ts}

@@ -10,13 +10,13 @@ import { TxHash } from '../tx/tx_hash.js';
 import { Note } from './note.js';
 
 /**
- * A note with contextual data.
+ * A note with contextual data and a nonce that makes it unique.
  */
-export class ExtendedNote {
+export class UniqueNote {
   constructor(
     /** The note as emitted from the Noir contract. */
     public note: Note,
-    /** The address whose public key was used to encrypt the note. */
+    /** The recipient whose public key was used to encrypt the note. */
     public recipient: AztecAddress,
     /** The contract address this note is created in. */
     public contractAddress: AztecAddress,
@@ -24,76 +24,11 @@ export class ExtendedNote {
     public storageSlot: Fr,
     /** The hash of the tx the note was created in. */
     public txHash: TxHash,
-  ) {}
-
-  toBuffer(): Buffer {
-    return serializeToBuffer([this.note, this.recipient, this.contractAddress, this.storageSlot, this.txHash]);
-  }
-
-  static fromBuffer(buffer: Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-
-    const note = reader.readObject(Note);
-    const recipient = reader.readObject(AztecAddress);
-    const contractAddress = reader.readObject(AztecAddress);
-    const storageSlot = reader.readObject(Fr);
-    const txHash = reader.readObject(TxHash);
-
-    return new this(note, recipient, contractAddress, storageSlot, txHash);
-  }
-
-  static get schema(): ZodFor<ExtendedNote> {
-    return z
-      .object({
-        note: Note.schema,
-        recipient: schemas.AztecAddress,
-        contractAddress: schemas.AztecAddress,
-        storageSlot: schemas.Fr,
-        txHash: TxHash.schema,
-      })
-      .transform(({ note, recipient, contractAddress, storageSlot, txHash }) => {
-        return new ExtendedNote(note, recipient, contractAddress, storageSlot, txHash);
-      });
-  }
-
-  toString() {
-    return bufferToHex(this.toBuffer());
-  }
-
-  static fromString(str: string) {
-    return ExtendedNote.fromBuffer(hexToBuffer(str));
-  }
-
-  static async random() {
-    return new ExtendedNote(
-      Note.random(),
-      await AztecAddress.random(),
-      await AztecAddress.random(),
-      Fr.random(),
-      TxHash.random(),
-    );
-  }
-}
-
-export class UniqueNote extends ExtendedNote {
-  constructor(
-    /** The note as emitted from the Noir contract. */
-    note: Note,
-    /** The recipient whose public key was used to encrypt the note. */
-    recipient: AztecAddress,
-    /** The contract address this note is created in. */
-    contractAddress: AztecAddress,
-    /** The specific storage location of the note on the contract. */
-    storageSlot: Fr,
-    /** The hash of the tx the note was created in. */
-    txHash: TxHash,
     /** The nonce that was injected into the note hash preimage in order to guarantee uniqueness. */
     public noteNonce: Fr,
-  ) {
-    super(note, recipient, contractAddress, storageSlot, txHash);
-  }
+  ) {}
 
-  static override get schema() {
+  static get schema(): ZodFor<UniqueNote> {
     return z
       .object({
         note: Note.schema,
@@ -108,7 +43,7 @@ export class UniqueNote extends ExtendedNote {
       });
   }
 
-  override toBuffer(): Buffer {
+  toBuffer(): Buffer {
     return serializeToBuffer([
       this.note,
       this.recipient,
@@ -119,7 +54,7 @@ export class UniqueNote extends ExtendedNote {
     ]);
   }
 
-  static override async random() {
+  static async random() {
     return new UniqueNote(
       Note.random(),
       await AztecAddress.random(),
@@ -130,7 +65,7 @@ export class UniqueNote extends ExtendedNote {
     );
   }
 
-  static override fromBuffer(buffer: Buffer | BufferReader) {
+  static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
 
     const note = reader.readObject(Note);
@@ -140,10 +75,14 @@ export class UniqueNote extends ExtendedNote {
     const txHash = reader.readObject(TxHash);
     const noteNonce = reader.readObject(Fr);
 
-    return new this(note, recipient, contractAddress, storageSlot, txHash, noteNonce);
+    return new UniqueNote(note, recipient, contractAddress, storageSlot, txHash, noteNonce);
   }
 
-  static override fromString(str: string) {
+  static fromString(str: string) {
     return UniqueNote.fromBuffer(hexToBuffer(str));
   }
+
+  toString() {
+    return bufferToHex(this.toBuffer());
+  }
 }

package/src/p2p/block_attestation.ts

@@ -1,5 +1,5 @@
 import { Buffer32 } from '@aztec/foundation/buffer';
-import { keccak256, recoverAddress } from '@aztec/foundation/crypto';
+import { keccak256, tryRecoverAddress } from '@aztec/foundation/crypto';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
 import { Fr } from '@aztec/foundation/fields';
@@ -7,8 +7,7 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { z } from 'zod';
 
-import { type ZodFor, schemas } from '../schemas/index.js';
-import type { UInt32 } from '../types/index.js';
+import type { ZodFor } from '../schemas/index.js';
 import { ConsensusPayload } from './consensus_payload.js';
 import { Gossipable } from './gossipable.js';
 import { SignatureDomainSeparator, getHashedSignaturePayloadEthSignedMessage } from './signature_utils.js';
@@ -30,16 +29,17 @@ export class BlockAttestation extends Gossipable {
   static override p2pTopic = TopicType.block_attestation;
 
   private sender: EthAddress | undefined;
+  private proposer: EthAddress | undefined;
 
   constructor(
-    /** The block number of the attestation. */
-    public readonly blockNumber: UInt32,
-
     /** The payload of the message, and what the signature is over */
     public readonly payload: ConsensusPayload,
 
     /** The signature of the block attester */
     public readonly signature: Signature,
+
+    /** The signature from the block proposer */
+    public readonly proposerSignature: Signature,
   ) {
     super();
   }
@@ -47,11 +47,11 @@ export class BlockAttestation extends Gossipable {
   static get schema(): ZodFor<BlockAttestation> {
     return z
       .object({
-        blockNumber: schemas.UInt32,
         payload: ConsensusPayload.schema,
         signature: Signature.schema,
+        proposerSignature: Signature.schema,
       })
-      .transform(obj => new BlockAttestation(obj.blockNumber, obj.payload, obj.signature));
+      .transform(obj => new BlockAttestation(obj.payload, obj.signature, obj.proposerSignature));
   }
 
   override generateP2PMessageIdentifier(): Promise<Buffer32> {
@@ -68,37 +68,68 @@ export class BlockAttestation extends Gossipable {
 
   /**
    * Lazily evaluate and cache the signer of the attestation
-   * @returns The signer of the attestation
+   * @returns The signer of the attestation, or undefined if signature recovery fails
    */
-  getSender(): EthAddress {
+  getSender(): EthAddress | undefined {
     if (!this.sender) {
       // Recover the sender from the attestation
       const hashed = getHashedSignaturePayloadEthSignedMessage(this.payload, SignatureDomainSeparator.blockAttestation);
       // Cache the sender for later use
-      this.sender = recoverAddress(hashed, this.signature);
+      this.sender = tryRecoverAddress(hashed, this.signature);
     }
 
     return this.sender;
   }
 
+  /**
+   * Lazily evaluate and cache the proposer of the block
+   * @returns The proposer of the block
+   */
+  getProposer(): EthAddress | undefined {
+    if (!this.proposer) {
+      // Recover the proposer from the proposal signature
+      const hashed = getHashedSignaturePayloadEthSignedMessage(this.payload, SignatureDomainSeparator.blockProposal);
+      // Cache the proposer for later use
+      this.proposer = tryRecoverAddress(hashed, this.proposerSignature);
+    }
+
+    return this.proposer;
+  }
+
   getPayload(): Buffer {
     return this.payload.getPayloadToSign(SignatureDomainSeparator.blockAttestation);
   }
 
   toBuffer(): Buffer {
-    return serializeToBuffer([this.blockNumber, this.payload, this.signature]);
+    return serializeToBuffer([this.payload, this.signature, this.proposerSignature]);
   }
 
   static fromBuffer(buf: Buffer | BufferReader): BlockAttestation {
     const reader = BufferReader.asReader(buf);
-    return new BlockAttestation(reader.readNumber(), reader.readObject(ConsensusPayload), reader.readObject(Signature));
+    return new BlockAttestation(
+      reader.readObject(ConsensusPayload),
+      reader.readObject(Signature),
+      reader.readObject(Signature),
+    );
   }
 
   static empty(): BlockAttestation {
-    return new BlockAttestation(0, ConsensusPayload.empty(), Signature.empty());
+    return new BlockAttestation(ConsensusPayload.empty(), Signature.empty(), Signature.empty());
+  }
+
+  static random(): BlockAttestation {
+    return new BlockAttestation(ConsensusPayload.random(), Signature.random(), Signature.random());
   }
 
   getSize(): number {
-    return 4 /* blockNumber */ + this.payload.getSize() + this.signature.getSize();
+    return this.payload.getSize() + this.signature.getSize() + this.proposerSignature.getSize();
+  }
+
+  toInspect() {
+    return {
+      payload: this.payload.toInspect(),
+      signature: this.signature.toString(),
+      proposerSignature: this.proposerSignature.toString(),
+    };
   }
 }

package/src/p2p/block_proposal.ts

@@ -1,14 +1,13 @@
 import { Buffer32 } from '@aztec/foundation/buffer';
-import { keccak256, recoverAddress } from '@aztec/foundation/crypto';
+import { keccak256, tryRecoverAddress } from '@aztec/foundation/crypto';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
-import type { BlockInfo } from '../block/l2_block.js';
+import type { L2BlockInfo } from '../block/l2_block_info.js';
 import { TxHash } from '../tx/index.js';
 import { Tx } from '../tx/tx.js';
-import type { UInt32 } from '../types/index.js';
 import { ConsensusPayload } from './consensus_payload.js';
 import { Gossipable } from './gossipable.js';
 import {
@@ -26,6 +25,8 @@ export class BlockProposalHash extends Buffer32 {
 
 export type BlockProposalOptions = {
   publishFullTxs: boolean;
+  /** Whether to generate an invalid block proposal for broadcasting. Use only for testing. */
+  broadcastInvalidBlockProposal?: boolean;
 };
 
 /**
@@ -40,9 +41,6 @@ export class BlockProposal extends Gossipable {
   private sender: EthAddress | undefined;
 
   constructor(
-    /** The number of the block */
-    public readonly blockNumber: UInt32,
-
     /** The payload of the message, and what the signature is over */
     public readonly payload: ConsensusPayload,
 
@@ -71,17 +69,17 @@ export class BlockProposal extends Gossipable {
     return this.payload.header.slotNumber;
   }
 
-  toBlockInfo(): BlockInfo {
+  toBlockInfo(): Omit<L2BlockInfo, 'blockNumber'> {
     return {
-      blockNumber: this.blockNumber,
       slotNumber: this.slotNumber.toNumber(),
-      archive: this.archive.toString(),
+      lastArchive: this.payload.header.lastArchiveRoot,
+      timestamp: this.payload.header.timestamp,
+      archive: this.archive,
       txCount: this.txHashes.length,
     };
   }
 
   static async createProposalFromSigner(
-    blockNumber: UInt32,
     payload: ConsensusPayload,
     txHashes: TxHash[],
     // Note(md): Provided separately to tx hashes such that this function can be optional
@@ -91,17 +89,18 @@ export class BlockProposal extends Gossipable {
     const hashed = getHashedSignaturePayload(payload, SignatureDomainSeparator.blockProposal);
     const sig = await payloadSigner(hashed);
 
-    return new BlockProposal(blockNumber, payload, sig, txHashes, txs);
+    return new BlockProposal(payload, sig, txHashes, txs);
   }
 
   /**Get Sender
    * Lazily evaluate the sender of the proposal; result is cached
+   * @returns The sender address, or undefined if signature recovery fails
    */
-  getSender() {
+  getSender(): EthAddress | undefined {
     if (!this.sender) {
       const hashed = getHashedSignaturePayloadEthSignedMessage(this.payload, SignatureDomainSeparator.blockProposal);
       // Cache the sender for later use
-      this.sender = recoverAddress(hashed, this.signature);
+      this.sender = tryRecoverAddress(hashed, this.signature);
     }
 
     return this.sender;
@@ -112,7 +111,7 @@ export class BlockProposal extends Gossipable {
   }
 
   toBuffer(): Buffer {
-    const buffer: any[] = [this.blockNumber, this.payload, this.signature, this.txHashes.length, this.txHashes];
+    const buffer: any[] = [this.payload, this.signature, this.txHashes.length, this.txHashes];
     if (this.txs) {
       buffer.push(this.txs.length);
       buffer.push(this.txs);
@@ -123,22 +122,20 @@ export class BlockProposal extends Gossipable {
   static fromBuffer(buf: Buffer | BufferReader): BlockProposal {
     const reader = BufferReader.asReader(buf);
 
-    const blockNumber = reader.readNumber();
     const payload = reader.readObject(ConsensusPayload);
     const sig = reader.readObject(Signature);
     const txHashes = reader.readArray(reader.readNumber(), TxHash);
 
     if (!reader.isEmpty()) {
       const txs = reader.readArray(reader.readNumber(), Tx);
-      return new BlockProposal(blockNumber, payload, sig, txHashes, txs);
+      return new BlockProposal(payload, sig, txHashes, txs);
     }
 
-    return new BlockProposal(blockNumber, payload, sig, txHashes);
+    return new BlockProposal(payload, sig, txHashes);
   }
 
   getSize(): number {
     return (
-      4 /* blockNumber */ +
       this.payload.getSize() +
       this.signature.getSize() +
       4 /* txHashes.length */ +

package/src/p2p/consensus_payload.ts

@@ -8,7 +8,8 @@ import { encodeAbiParameters, parseAbiParameters } from 'viem';
 import { z } from 'zod';
 
 import type { L2Block } from '../block/l2_block.js';
-import { ProposedBlockHeader, StateReference } from '../tx/index.js';
+import { CheckpointHeader } from '../rollup/checkpoint_header.js';
+import { StateReference } from '../tx/state_reference.js';
 import type { Signable, SignatureDomainSeparator } from './signature_utils.js';
 
 export class ConsensusPayload implements Signable {
@@ -16,7 +17,7 @@ export class ConsensusPayload implements Signable {
 
   constructor(
     /** The proposed block header the attestation is made over */
-    public readonly header: ProposedBlockHeader,
+    public readonly header: CheckpointHeader,
     /** The archive root after the block is added */
     public readonly archive: Fr,
     /** The state reference after the block is added */
@@ -26,7 +27,7 @@ export class ConsensusPayload implements Signable {
   static get schema() {
     return z
       .object({
-        header: ProposedBlockHeader.schema,
+        header: CheckpointHeader.schema,
         archive: schemas.Fr,
         stateReference: StateReference.schema,
       })
@@ -60,18 +61,25 @@ export class ConsensusPayload implements Signable {
   }
 
   toBuffer(): Buffer {
-    const buffer = serializeToBuffer([this.header, this.archive, this.stateReference]);
-    this.size = buffer.length;
-    return buffer;
+    return serializeToBuffer([this.header, this.archive, this.stateReference]);
+  }
+
+  public equals(other: ConsensusPayload): boolean {
+    return (
+      this.header.equals(other.header) &&
+      this.archive.equals(other.archive) &&
+      this.stateReference.equals(other.stateReference)
+    );
   }
 
   static fromBuffer(buf: Buffer | BufferReader): ConsensusPayload {
     const reader = BufferReader.asReader(buf);
-    return new ConsensusPayload(
-      reader.readObject(ProposedBlockHeader),
+    const payload = new ConsensusPayload(
+      reader.readObject(CheckpointHeader),
       reader.readObject(Fr),
       reader.readObject(StateReference),
     );
+    return payload;
   }
 
   static fromFields(fields: FieldsOf<ConsensusPayload>): ConsensusPayload {
@@ -79,11 +87,15 @@ export class ConsensusPayload implements Signable {
   }
 
   static fromBlock(block: L2Block): ConsensusPayload {
-    return new ConsensusPayload(block.header.toPropose(), block.archive.root, block.header.state);
+    return new ConsensusPayload(block.header.toCheckpointHeader(), block.archive.root, block.header.state);
   }
 
   static empty(): ConsensusPayload {
-    return new ConsensusPayload(ProposedBlockHeader.empty(), Fr.ZERO, StateReference.empty());
+    return new ConsensusPayload(CheckpointHeader.empty(), Fr.ZERO, StateReference.empty());
+  }
+
+  static random(): ConsensusPayload {
+    return new ConsensusPayload(CheckpointHeader.random(), Fr.random(), StateReference.random());
   }
 
   /**
@@ -99,6 +111,14 @@ export class ConsensusPayload implements Signable {
     return this.size;
   }
 
+  toInspect() {
+    return {
+      header: this.header.toInspect(),
+      archive: this.archive.toString(),
+      stateReference: this.stateReference.toInspect(),
+    };
+  }
+
   toString() {
     return `header: ${this.header.toString()}, archive: ${this.archive.toString()}, stateReference: ${this.stateReference.l1ToL2MessageTree.root.toString()}`;
   }