@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.5476d83

package/src/note/note_dao.ts

@@ -0,0 +1,151 @@
+import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
+import { Fr, Point } from '@aztec/foundation/fields';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { Note } from '@aztec/stdlib/note';
+import { TxHash } from '@aztec/stdlib/tx';
+
+/**
+ * A Note Data Access Object, representing a note that was committed to the note hash tree, holding all of the
+ * information required to use it during execution and manage its state.
+ */
+export class NoteDao {
+  constructor(
+    // Note information
+
+    /** The packed content of the note, as will be returned in the getNotes oracle. */
+    public note: Note,
+    /** The address of the contract that created the note (i.e. the address used by the kernel during siloing). */
+    public contractAddress: AztecAddress,
+    /**
+     * The storage location of the note. This value is not used for anything in PXE, but we do index by storage slot
+     * since contracts typically make queries based on it.
+     */
+    public storageSlot: Fr,
+    /**
+     * The randomness injected to the note.
+     */
+    public randomness: Fr,
+    /** The nonce that was injected into the note hash preimage in order to guarantee uniqueness. */
+    public noteNonce: Fr,
+
+    // Computed values
+    /**
+     * The inner hash (non-unique, non-siloed) of the note. Each contract determines how the note is hashed. Can
+     * be used alongside contractAddress and nonce to compute the uniqueNoteHash and the siloedNoteHash.
+     */
+    public noteHash: Fr,
+    /**
+     * The nullifier of the note, siloed by contract address.
+     * Note: Might be set as 0 if the note was added to PXE as nullified.
+     */
+    public siloedNullifier: Fr,
+
+    // Metadata
+    /** The hash of the tx in which this note was created. Knowing the tx hash allows for efficient node queries e.g.
+     *  when searching for txEffects.
+     */
+    public txHash: TxHash,
+    /** The L2 block number in which the tx with this note was included. Used for note management while processing
+     * reorgs.*/
+    public l2BlockNumber: number,
+    /** The L2 block hash in which the tx with this note was included. Used for note management while processing
+     * reorgs.*/
+    public l2BlockHash: string,
+    /** The index of the leaf in the global note hash tree the note is stored at */
+    public index: bigint,
+  ) {}
+
+  toBuffer(): Buffer {
+    return serializeToBuffer([
+      this.note,
+      this.contractAddress,
+      this.storageSlot,
+      this.randomness,
+      this.noteNonce,
+      this.noteHash,
+      this.siloedNullifier,
+      this.txHash,
+      this.l2BlockNumber,
+      Fr.fromHexString(this.l2BlockHash),
+      this.index,
+    ]);
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+
+    const note = Note.fromBuffer(reader);
+    const contractAddress = AztecAddress.fromBuffer(reader);
+    const storageSlot = Fr.fromBuffer(reader);
+    const randomness = Fr.fromBuffer(reader);
+    const noteNonce = Fr.fromBuffer(reader);
+    const noteHash = Fr.fromBuffer(reader);
+    const siloedNullifier = Fr.fromBuffer(reader);
+    const txHash = reader.readObject(TxHash);
+    const l2BlockNumber = reader.readNumber();
+    const l2BlockHash = Fr.fromBuffer(reader).toString();
+    const index = toBigIntBE(reader.readBytes(32));
+
+    return new NoteDao(
+      note,
+      contractAddress,
+      storageSlot,
+      randomness,
+      noteNonce,
+      noteHash,
+      siloedNullifier,
+      txHash,
+      l2BlockNumber,
+      l2BlockHash,
+      index,
+    );
+  }
+
+  toString() {
+    return '0x' + this.toBuffer().toString('hex');
+  }
+
+  static fromString(str: string) {
+    const hex = str.replace(/^0x/, '');
+    return NoteDao.fromBuffer(Buffer.from(hex, 'hex'));
+  }
+
+  /**
+   * Returns the size in bytes of the Note Dao.
+   * @returns - Its size in bytes.
+   */
+  public getSize() {
+    const indexSize = Math.ceil(Math.log2(Number(this.index)));
+    const noteSize = 4 + this.note.items.length * Fr.SIZE_IN_BYTES;
+    return noteSize + AztecAddress.SIZE_IN_BYTES + Fr.SIZE_IN_BYTES * 4 + TxHash.SIZE + Point.SIZE_IN_BYTES + indexSize;
+  }
+
+  static async random({
+    note = Note.random(),
+    contractAddress = undefined,
+    storageSlot = Fr.random(),
+    randomness = Fr.random(),
+    noteNonce = Fr.random(),
+    noteHash = Fr.random(),
+    siloedNullifier = Fr.random(),
+    txHash = TxHash.random(),
+    l2BlockNumber = Math.floor(Math.random() * 1000),
+    l2BlockHash = Fr.random().toString(),
+    index = Fr.random().toBigInt(),
+  }: Partial<NoteDao> = {}) {
+    return new NoteDao(
+      note,
+      contractAddress ?? (await AztecAddress.random()),
+      storageSlot,
+      randomness,
+      noteNonce,
+      noteHash,
+      siloedNullifier,
+      txHash,
+      l2BlockNumber,
+      l2BlockHash,
+      index,
+    );
+  }
+}

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';
 
 /**
@@ -12,14 +11,13 @@ import { NoteStatus } from './note_status.js';
  * @remarks This filter is applied as an intersection of all its params.
  */
 export type NotesFilter = {
-  /** Hash of a transaction from which to fetch the notes. */
-  txHash?: TxHash;
-  /** The contract address the note belongs to. */
-  contractAddress?: AztecAddress;
+  /**
+   * The contract address the note belongs to.
+   * @remarks Providing a contract address is required as we need that information to trigger private state sync.
+   */
+  contractAddress: AztecAddress;
   /** The specific storage location of the note on the contract. */
   storageSlot?: Fr;
-  /** The owner of the note (whose public key was used to encrypt the note). */
-  owner?: AztecAddress;
   /** The status of the note. Defaults to 'ACTIVE'. */
   status?: NoteStatus;
   /** The siloed nullifier for the note. */
@@ -29,10 +27,8 @@ export type NotesFilter = {
 };
 
 export const NotesFilterSchema: ZodFor<NotesFilter> = z.object({
-  txHash: TxHash.schema.optional(),
-  contractAddress: schemas.AztecAddress.optional(),
+  contractAddress: schemas.AztecAddress,
   storageSlot: schemas.Fr.optional(),
-  owner: schemas.AztecAddress.optional(),
   status: z.nativeEnum(NoteStatus).optional(),
   siloedNullifier: schemas.Fr.optional(),
   scopes: z.array(schemas.AztecAddress).optional(),

package/src/p2p/attestation_utils.ts

@@ -0,0 +1,35 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+
+import { CommitteeAttestation } from '../block/index.js';
+import type { BlockAttestation } from './block_attestation.js';
+
+/**
+ * Returns attestation signatures in the order of a series of provided ethereum addresses
+ * The rollup smart contract expects attestations to appear in the order of the committee
+ * @todo: perform this logic within the memory attestation store instead?
+ */
+export function orderAttestations(
+  attestations: BlockAttestation[],
+  orderAddresses: EthAddress[],
+): CommitteeAttestation[] {
+  // Create a map of sender addresses to BlockAttestations
+  const attestationMap = new Map<string, CommitteeAttestation>();
+
+  for (const attestation of attestations) {
+    const sender = attestation.getSender();
+    if (sender) {
+      attestationMap.set(
+        sender.toString(),
+        CommitteeAttestation.fromAddressAndSignature(sender, attestation.signature),
+      );
+    }
+  }
+
+  // Create the ordered array based on the orderAddresses, else return an empty attestation
+  const orderedAttestations = orderAddresses.map(address => {
+    const addressString = address.toString();
+    return attestationMap.get(addressString) || CommitteeAttestation.fromAddress(address);
+  });
+
+  return orderedAttestations;
+}

package/src/p2p/block_attestation.ts

@@ -1,8 +1,9 @@
+import { SlotNumber } from '@aztec/foundation/branded-types';
 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 type { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { z } from 'zod';
@@ -11,7 +12,7 @@ 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';
-import { TopicType, createTopicString } from './topic_type.js';
+import { TopicType } from './topic_type.js';
 
 export class BlockAttestationHash extends Buffer32 {
   constructor(hash: Buffer) {
@@ -26,9 +27,10 @@ export class BlockAttestationHash extends Buffer32 {
  * will produce a block attestation over the header of the block
  */
 export class BlockAttestation extends Gossipable {
-  static override p2pTopic = createTopicString(TopicType.block_attestation);
+  static override p2pTopic = TopicType.block_attestation;
 
   private sender: EthAddress | undefined;
+  private proposer: EthAddress | undefined;
 
   constructor(
     /** The payload of the message, and what the signature is over */
@@ -36,6 +38,9 @@ export class BlockAttestation extends Gossipable {
 
     /** The signature of the block attester */
     public readonly signature: Signature,
+
+    /** The signature from the block proposer */
+    public readonly proposerSignature: Signature,
   ) {
     super();
   }
@@ -45,11 +50,12 @@ export class BlockAttestation extends Gossipable {
       .object({
         payload: ConsensusPayload.schema,
         signature: Signature.schema,
+        proposerSignature: Signature.schema,
       })
-      .transform(obj => new BlockAttestation(obj.payload, obj.signature));
+      .transform(obj => new BlockAttestation(obj.payload, obj.signature, obj.proposerSignature));
   }
 
-  override p2pMessageIdentifier(): Promise<Buffer32> {
+  override generateP2PMessageIdentifier(): Promise<Buffer32> {
     return Promise.resolve(new BlockAttestationHash(keccak256(this.signature.toBuffer())));
   }
 
@@ -57,51 +63,74 @@ export class BlockAttestation extends Gossipable {
     return this.payload.archive;
   }
 
-  get slotNumber(): Fr {
-    return this.payload.header.globalVariables.slotNumber;
-  }
-
-  get blockNumber(): Fr {
-    return this.payload.header.globalVariables.blockNumber;
+  get slotNumber(): SlotNumber {
+    return this.payload.header.slotNumber;
   }
 
-  /**Get sender
-   *
-   * Lazily evaluate and cache the sender of the attestation
-   * @returns The sender of the attestation
+  /**
+   * Lazily evaluate and cache the signer of the attestation
+   * @returns The signer of the attestation, or undefined if signature recovery fails
    */
-  async getSender(): Promise<EthAddress> {
+  getSender(): EthAddress | undefined {
     if (!this.sender) {
       // Recover the sender from the attestation
-      const hashed = await getHashedSignaturePayloadEthSignedMessage(
-        this.payload,
-        SignatureDomainSeparator.blockAttestation,
-      );
+      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;
   }
 
-  getPayload(): Promise<Buffer> {
+  /**
+   * 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.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.readObject(ConsensusPayload), reader.readObject(Signature));
+    return new BlockAttestation(
+      reader.readObject(ConsensusPayload),
+      reader.readObject(Signature),
+      reader.readObject(Signature),
+    );
   }
 
   static empty(): BlockAttestation {
-    return new BlockAttestation(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 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,10 +1,14 @@
+import { SlotNumber } from '@aztec/foundation/branded-types';
 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 type { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
+import type { L2BlockInfo } from '../block/l2_block_info.js';
+import { TxHash } from '../tx/index.js';
+import { Tx } from '../tx/tx.js';
 import { ConsensusPayload } from './consensus_payload.js';
 import { Gossipable } from './gossipable.js';
 import {
@@ -12,7 +16,7 @@ import {
   getHashedSignaturePayload,
   getHashedSignaturePayloadEthSignedMessage,
 } from './signature_utils.js';
-import { TopicType, createTopicString } from './topic_type.js';
+import { TopicType } from './topic_type.js';
 
 export class BlockProposalHash extends Buffer32 {
   constructor(hash: Buffer) {
@@ -20,6 +24,12 @@ 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;
+};
+
 /**
  * BlockProposal
  *
@@ -27,7 +37,7 @@ export class BlockProposalHash extends Buffer32 {
  * be included in the head of the chain
  */
 export class BlockProposal extends Gossipable {
-  static override p2pTopic = createTopicString(TopicType.block_proposal);
+  static override p2pTopic = TopicType.block_proposal;
 
   private sender: EthAddress | undefined;
 
@@ -37,11 +47,18 @@ export class BlockProposal extends Gossipable {
 
     /** The signer of the BlockProposal over the header of the new block*/
     public readonly signature: Signature,
+
+    /** The sequence of transactions in the block */
+    public readonly txHashes: TxHash[],
+
+    // Note(md): this is placed after the txs payload in order to be backwards compatible with previous versions
+    /** The transactions in the block */
+    public readonly txs?: Tx[],
   ) {
     super();
   }
 
-  override p2pMessageIdentifier(): Promise<Buffer32> {
+  override generateP2PMessageIdentifier(): Promise<Buffer32> {
     return Promise.resolve(new BlockProposalHash(keccak256(this.signature.toBuffer())));
   }
 
@@ -49,35 +66,42 @@ export class BlockProposal extends Gossipable {
     return this.payload.archive;
   }
 
-  get slotNumber(): Fr {
-    return this.payload.header.globalVariables.slotNumber;
+  get slotNumber(): SlotNumber {
+    return this.payload.header.slotNumber;
   }
 
-  get blockNumber(): Fr {
-    return this.payload.header.globalVariables.blockNumber;
+  toBlockInfo(): Omit<L2BlockInfo, 'blockNumber'> {
+    return {
+      slotNumber: this.slotNumber,
+      lastArchive: this.payload.header.lastArchiveRoot,
+      timestamp: this.payload.header.timestamp,
+      archive: this.archive,
+      txCount: this.txHashes.length,
+    };
   }
 
   static async createProposalFromSigner(
     payload: ConsensusPayload,
+    txHashes: TxHash[],
+    // Note(md): Provided separately to tx hashes such that this function can be optional
+    txs: Tx[] | undefined,
     payloadSigner: (payload: Buffer32) => Promise<Signature>,
   ) {
-    const hashed = await getHashedSignaturePayload(payload, SignatureDomainSeparator.blockProposal);
+    const hashed = getHashedSignaturePayload(payload, SignatureDomainSeparator.blockProposal);
     const sig = await payloadSigner(hashed);
 
-    return new BlockProposal(payload, sig);
+    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
    */
-  async getSender() {
+  getSender(): EthAddress | undefined {
     if (!this.sender) {
-      const hashed = await getHashedSignaturePayloadEthSignedMessage(
-        this.payload,
-        SignatureDomainSeparator.blockProposal,
-      );
+      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;
@@ -88,15 +112,36 @@ export class BlockProposal extends Gossipable {
   }
 
   toBuffer(): Buffer {
-    return serializeToBuffer([this.payload, this.signature]);
+    const buffer: any[] = [this.payload, this.signature, this.txHashes.length, this.txHashes];
+    if (this.txs) {
+      buffer.push(this.txs.length);
+      buffer.push(this.txs);
+    }
+    return serializeToBuffer(buffer);
   }
 
   static fromBuffer(buf: Buffer | BufferReader): BlockProposal {
     const reader = BufferReader.asReader(buf);
-    return new BlockProposal(reader.readObject(ConsensusPayload), reader.readObject(Signature));
+
+    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(payload, sig, txHashes, txs);
+    }
+
+    return new BlockProposal(payload, sig, txHashes);
   }
 
   getSize(): number {
-    return this.payload.getSize() + this.signature.getSize();
+    return (
+      this.payload.getSize() +
+      this.signature.getSize() +
+      4 /* txHashes.length */ +
+      this.txHashes.length * TxHash.SIZE +
+      (this.txs ? 4 /* txs.length */ + this.txs.reduce((acc, tx) => acc + tx.getSize(), 0) : 0)
+    );
   }
 }

package/src/p2p/consensus_payload.ts

@@ -7,74 +7,86 @@ import type { FieldsOf } from '@aztec/foundation/types';
 import { encodeAbiParameters, parseAbiParameters } from 'viem';
 import { z } from 'zod';
 
-import { BlockHeader } from '../tx/block_header.js';
-import { TxHash } from '../tx/tx_hash.js';
+import type { L2Block } from '../block/l2_block.js';
+import type { Checkpoint } from '../checkpoint/checkpoint.js';
+import { CheckpointHeader } from '../rollup/checkpoint_header.js';
 import type { Signable, SignatureDomainSeparator } from './signature_utils.js';
 
 export class ConsensusPayload implements Signable {
   private size: number | undefined;
 
   constructor(
-    /** The block header the attestation is made over */
-    public readonly header: BlockHeader,
-    // TODO(https://github.com/AztecProtocol/aztec-packages/pull/7727#discussion_r1713670830): temporary
+    /** The proposed block header the attestation is made over */
+    public readonly header: CheckpointHeader,
+    /** The archive root after the block is added */
     public readonly archive: Fr,
-    /** The sequence of transactions in the block */
-    public readonly txHashes: TxHash[],
   ) {}
 
   static get schema() {
     return z
       .object({
-        header: BlockHeader.schema,
+        header: CheckpointHeader.schema,
         archive: schemas.Fr,
-        txHashes: z.array(TxHash.schema),
       })
-      .transform(obj => new ConsensusPayload(obj.header, obj.archive, obj.txHashes));
+      .transform(obj => new ConsensusPayload(obj.header, obj.archive));
   }
 
   static getFields(fields: FieldsOf<ConsensusPayload>) {
-    return [fields.header, fields.archive, fields.txHashes] as const;
+    return [fields.header, fields.archive] as const;
   }
 
-  async getPayloadToSign(domainSeparator: SignatureDomainSeparator): Promise<Buffer> {
-    const abi = parseAbiParameters('uint8, (bytes32, bytes32, (uint256), bytes, bytes32[])');
-    const txArray = this.txHashes.map(tx => tx.toString());
+  getPayloadToSign(domainSeparator: SignatureDomainSeparator): Buffer {
+    const abi = parseAbiParameters(
+      'uint8, ' + //domainSeperator
+        '(' +
+        'bytes32, ' + // archive
+        '(int256), ' + // oracleInput
+        'bytes32' + // headerHash
+        ')',
+    );
+    const archiveRoot = this.archive.toString();
+
+    const headerHash = this.header.hash().toString();
     const encodedData = encodeAbiParameters(abi, [
       domainSeparator,
-      [
-        this.archive.toString(),
-        (await this.header.hash()).toString(),
-        [0n] /* @todo See #9963 */,
-        this.header.toString(),
-        txArray,
-      ],
+      [archiveRoot, [0n] /* @todo See #9963 */, headerHash],
     ] as const);
 
     return hexToBuffer(encodedData);
   }
 
   toBuffer(): Buffer {
-    const buffer = serializeToBuffer([this.header, this.archive, this.txHashes.length, this.txHashes]);
-    this.size = buffer.length;
-    return buffer;
+    return serializeToBuffer([this.header, this.archive]);
+  }
+
+  public equals(other: ConsensusPayload): boolean {
+    return this.header.equals(other.header) && this.archive.equals(other.archive);
   }
 
   static fromBuffer(buf: Buffer | BufferReader): ConsensusPayload {
     const reader = BufferReader.asReader(buf);
-    return new ConsensusPayload(
-      reader.readObject(BlockHeader),
-      reader.readObject(Fr),
-      reader.readArray(reader.readNumber(), TxHash),
-    );
+    const payload = new ConsensusPayload(reader.readObject(CheckpointHeader), reader.readObject(Fr));
+    return payload;
   }
 
   static fromFields(fields: FieldsOf<ConsensusPayload>): ConsensusPayload {
-    return new ConsensusPayload(fields.header, fields.archive, fields.txHashes);
+    return new ConsensusPayload(fields.header, fields.archive);
+  }
+
+  static fromBlock(block: L2Block): ConsensusPayload {
+    return new ConsensusPayload(block.header.toCheckpointHeader(), block.archive.root);
+  }
+
+  static fromCheckpoint(checkpoint: Checkpoint): ConsensusPayload {
+    return new ConsensusPayload(checkpoint.header, checkpoint.archive.root);
   }
 
   static empty(): ConsensusPayload {
-    return new ConsensusPayload(BlockHeader.empty(), Fr.ZERO, []);
+    return new ConsensusPayload(CheckpointHeader.empty(), Fr.ZERO);
+  }
+
+  static random(): ConsensusPayload {
+    return new ConsensusPayload(CheckpointHeader.random(), Fr.random());
   }
 
   /**
@@ -89,4 +101,15 @@ export class ConsensusPayload implements Signable {
     this.size = this.toBuffer().length;
     return this.size;
   }
+
+  toInspect() {
+    return {
+      header: this.header.toInspect(),
+      archive: this.archive.toString(),
+    };
+  }
+
+  toString() {
+    return `header: ${this.header.toString()}, archive: ${this.archive.toString()}}`;
+  }
 }