@aztec/stdlib 0.86.0 → 0.87.0

package/src/logs/public_log.ts

@@ -1,9 +1,6 @@
-import {
-  PRIVATE_LOG_SIZE_IN_FIELDS,
-  PUBLIC_LOG_DATA_SIZE_IN_FIELDS,
-  PUBLIC_LOG_SIZE_IN_FIELDS,
-} from '@aztec/constants';
+import { PUBLIC_LOG_LENGTH, PUBLIC_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
 import { type FieldsOf, makeTuple } from '@aztec/foundation/array';
+import { padArrayEnd } from '@aztec/foundation/collection';
 import { Fr } from '@aztec/foundation/fields';
 import { type ZodFor, schemas } from '@aztec/foundation/schemas';
 import {
@@ -20,29 +17,61 @@ import { z } from 'zod';
 import { AztecAddress } from '../aztec-address/index.js';
 
 export class PublicLog {
-  static SIZE_IN_BYTES = Fr.SIZE_IN_BYTES * PUBLIC_LOG_SIZE_IN_FIELDS;
+  static SIZE_IN_BYTES = Fr.SIZE_IN_BYTES * PUBLIC_LOG_LENGTH;
 
-  constructor(public contractAddress: AztecAddress, public log: Tuple<Fr, typeof PUBLIC_LOG_DATA_SIZE_IN_FIELDS>) {}
+  constructor(
+    public contractAddress: AztecAddress,
+    public fields: Tuple<Fr, typeof PUBLIC_LOG_SIZE_IN_FIELDS>,
+    public emittedLength: number,
+  ) {}
 
-  toFields(): Fr[] {
-    return serializeToFields(...PublicLog.getFields(this));
+  static from(fields: FieldsOf<PublicLog>) {
+    return new PublicLog(...PublicLog.getFields(fields));
   }
 
   static getFields(fields: FieldsOf<PublicLog>) {
-    return [fields.contractAddress, fields.log] as const;
+    return [fields.contractAddress, fields.fields, fields.emittedLength] as const;
+  }
+
+  toFields(): Fr[] {
+    return serializeToFields(...PublicLog.getFields(this));
   }
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    return new PublicLog(reader.readObject(AztecAddress), reader.readFieldArray(PUBLIC_LOG_DATA_SIZE_IN_FIELDS));
+    return new PublicLog(
+      reader.readObject(AztecAddress),
+      reader.readFieldArray(PUBLIC_LOG_SIZE_IN_FIELDS),
+      reader.readU32(),
+    );
+  }
+
+  getEmittedFields() {
+    return this.fields.slice(0, this.emittedLength);
+  }
+
+  toBlobFields(): Fr[] {
+    return [new Fr(this.emittedLength), this.contractAddress.toField()].concat(this.getEmittedFields());
+  }
+
+  static fromBlobFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    const emittedLength = reader.readU32();
+    const contractAddress = reader.readObject(AztecAddress);
+    const emittedFields = reader.readFieldArray(emittedLength);
+    return new PublicLog(
+      contractAddress,
+      padArrayEnd(emittedFields, Fr.ZERO, PUBLIC_LOG_SIZE_IN_FIELDS),
+      emittedLength,
+    );
   }
 
   isEmpty() {
-    return this.contractAddress.isZero() && this.log.every(f => f.isZero());
+    return this.contractAddress.isZero() && this.fields.every(f => f.isZero()) && this.emittedLength === 0;
   }
 
   static empty() {
-    return new PublicLog(AztecAddress.ZERO, makeTuple(PUBLIC_LOG_DATA_SIZE_IN_FIELDS, Fr.zero));
+    return new PublicLog(AztecAddress.ZERO, makeTuple(PUBLIC_LOG_SIZE_IN_FIELDS, Fr.zero), 0);
   }
 
   toBuffer(): Buffer {
@@ -51,55 +80,50 @@ export class PublicLog {
 
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new PublicLog(reader.readObject(AztecAddress), reader.readArray(PUBLIC_LOG_DATA_SIZE_IN_FIELDS, Fr));
+    return new PublicLog(
+      reader.readObject(AztecAddress),
+      reader.readArray(PUBLIC_LOG_SIZE_IN_FIELDS, Fr),
+      reader.readNumber(),
+    );
   }
 
   static async random() {
-    return new PublicLog(await AztecAddress.random(), makeTuple(PUBLIC_LOG_DATA_SIZE_IN_FIELDS, Fr.random));
-  }
-
-  getEmittedLength() {
-    // This assumes that we cut trailing zeroes from the end of the log. In ts, these will always be added back.
-    // Does not include length prefix.
-    return this.getEmittedFields().length;
-  }
-
-  getEmittedFields() {
-    const fields = this.toFields();
-    const lastNonZeroIndex = fields.findLastIndex(f => !f.isZero());
-    return fields.slice(0, lastNonZeroIndex + 1);
+    return new PublicLog(
+      await AztecAddress.random(),
+      makeTuple(PUBLIC_LOG_SIZE_IN_FIELDS, Fr.random),
+      PUBLIC_LOG_SIZE_IN_FIELDS,
+    );
   }
 
   equals(other: this) {
     return (
       this.contractAddress.equals(other.contractAddress) &&
-      this.log.reduce((acc, field, i) => acc && field.equals(other.log[i]), true)
+      this.fields.every((field, i) => field.equals(other.fields[i])) &&
+      this.emittedLength === other.emittedLength
     );
   }
 
   toHumanReadable(): string {
-    return `PublicLog: (contractAddress: ${this.contractAddress} log: ${this.log})`;
+    return `PublicLog: (contractAddress: ${this.contractAddress} fields: ${this.fields}) emittedLength: ${this.emittedLength}`;
   }
 
   static get schema(): ZodFor<PublicLog> {
-    if (PUBLIC_LOG_DATA_SIZE_IN_FIELDS + 1 == PRIVATE_LOG_SIZE_IN_FIELDS) {
-      throw new Error(
-        'Constants got updated and schema for PrivateLog matches that of PublicLog. This needs to be updated now as Zod is no longer able to differentiate the 2 in TxScopedL2Log.',
-      );
-    }
-
     return z
       .object({
         contractAddress: AztecAddress.schema,
-        log: z.array(schemas.Fr),
+        fields: z.array(schemas.Fr).refine(arr => arr.length === PUBLIC_LOG_SIZE_IN_FIELDS),
+        emittedLength: z.number(),
       })
-      .transform(({ contractAddress, log }) => PublicLog.fromFields([contractAddress.toField(), ...log]));
+      .transform(({ contractAddress, fields, emittedLength }) =>
+        PublicLog.fromFields([contractAddress.toField(), ...fields, new Fr(emittedLength)]),
+      );
   }
 
   [inspect.custom](): string {
     return `PublicLog {
       contractAddress: ${inspect(this.contractAddress)},
-      log: [${this.log.map(x => inspect(x)).join(', ')}],
+      fields: [${this.fields.map(x => inspect(x)).join(', ')}],
+      emittedLength: ${this.emittedLength},
     }`;
   }
 }

package/src/logs/tx_scoped_l2_log.ts

@@ -75,8 +75,7 @@ export class TxScopedL2Log {
     return new TxScopedL2Log(txHash, dataStartIndexForTx, logIndexInTx, blockNumber, log);
   }
 
-  static async random() {
-    const isFromPublic = Math.random() < 0.5;
+  static async random(isFromPublic = Math.random() < 0.5) {
     const log = isFromPublic ? await PublicLog.random() : PrivateLog.random();
     return new TxScopedL2Log(TxHash.random(), 1, 1, 1, log);
   }

package/src/messaging/inbox_leaf.ts

@@ -25,4 +25,14 @@ export class InboxLeaf {
   static smallestIndexFromL2Block(l2block: bigint): bigint {
     return (l2block - BigInt(INITIAL_L2_BLOCK_NUM)) * BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
   }
+
+  /**
+   * Returns the range of valid indices for a given L2 block.
+   * Start index is inclusive, end index is exclusive.
+   */
+  static indexRangeFromL2Block(l2block: bigint): [bigint, bigint] {
+    const start = this.smallestIndexFromL2Block(l2block);
+    const end = start + BigInt(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP);
+    return [start, end];
+  }
 }

package/src/messaging/l2_to_l1_message.ts

@@ -10,7 +10,11 @@ import { z } from 'zod';
 import { AztecAddress } from '../aztec-address/index.js';
 
 export class L2ToL1Message {
-  constructor(public recipient: EthAddress, public content: Fr, public counter: number) {}
+  constructor(
+    public recipient: EthAddress,
+    public content: Fr,
+    public counter: number,
+  ) {}
 
   static get schema() {
     return z
@@ -97,7 +101,10 @@ export class L2ToL1Message {
 }
 
 export class ScopedL2ToL1Message {
-  constructor(public message: L2ToL1Message, public contractAddress: AztecAddress) {}
+  constructor(
+    public message: L2ToL1Message,
+    public contractAddress: AztecAddress,
+  ) {}
 
   static get schema() {
     return z

package/src/p2p/block_attestation.ts

@@ -2,7 +2,7 @@ import { Buffer32 } from '@aztec/foundation/buffer';
 import { keccak256, recoverAddress } 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';
@@ -31,6 +31,9 @@ export class BlockAttestation extends Gossipable {
   private sender: EthAddress | undefined;
 
   constructor(
+    /** The block number of the attestation. */
+    public readonly blockNumber: Fr,
+
     /** The payload of the message, and what the signature is over */
     public readonly payload: ConsensusPayload,
 
@@ -43,13 +46,14 @@ export class BlockAttestation extends Gossipable {
   static get schema(): ZodFor<BlockAttestation> {
     return z
       .object({
+        blockNumber: Fr.schema,
         payload: ConsensusPayload.schema,
         signature: Signature.schema,
       })
-      .transform(obj => new BlockAttestation(obj.payload, obj.signature));
+      .transform(obj => new BlockAttestation(obj.blockNumber, obj.payload, obj.signature));
   }
 
-  override p2pMessageIdentifier(): Promise<Buffer32> {
+  override generateP2PMessageIdentifier(): Promise<Buffer32> {
     return Promise.resolve(new BlockAttestationHash(keccak256(this.signature.toBuffer())));
   }
 
@@ -58,11 +62,7 @@ export class BlockAttestation extends Gossipable {
   }
 
   get slotNumber(): Fr {
-    return this.payload.header.globalVariables.slotNumber;
-  }
-
-  get blockNumber(): Fr {
-    return this.payload.header.globalVariables.blockNumber;
+    return this.payload.header.slotNumber;
   }
 
   /**Get sender
@@ -86,19 +86,23 @@ export class BlockAttestation extends Gossipable {
   }
 
   toBuffer(): Buffer {
-    return serializeToBuffer([this.payload, this.signature]);
+    return serializeToBuffer([this.blockNumber, this.payload, this.signature]);
   }
 
   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(Fr),
+      reader.readObject(ConsensusPayload),
+      reader.readObject(Signature),
+    );
   }
 
   static empty(): BlockAttestation {
-    return new BlockAttestation(ConsensusPayload.empty(), Signature.empty());
+    return new BlockAttestation(Fr.ZERO, ConsensusPayload.empty(), Signature.empty());
   }
 
   getSize(): number {
-    return this.payload.getSize() + this.signature.getSize();
+    return this.blockNumber.size + this.payload.getSize() + this.signature.getSize();
   }
 }

package/src/p2p/block_proposal.ts

@@ -2,9 +2,10 @@ import { Buffer32 } from '@aztec/foundation/buffer';
 import { keccak256, recoverAddress } 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 { Tx } from '../tx/tx.js';
 import { ConsensusPayload } from './consensus_payload.js';
 import { Gossipable } from './gossipable.js';
 import {
@@ -20,6 +21,10 @@ export class BlockProposalHash extends Buffer32 {
   }
 }
 
+export type BlockProposalOptions = {
+  publishFullTxs: boolean;
+};
+
 /**
  * BlockProposal
  *
@@ -32,16 +37,23 @@ export class BlockProposal extends Gossipable {
   private sender: EthAddress | undefined;
 
   constructor(
+    /** The number of the block */
+    public readonly blockNumber: Fr,
+
     /** The payload of the message, and what the signature is over */
     public readonly payload: ConsensusPayload,
 
     /** The signer of the BlockProposal over the header of the new block*/
     public readonly signature: Signature,
+
+    // 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())));
   }
 
@@ -50,21 +62,20 @@ export class BlockProposal extends Gossipable {
   }
 
   get slotNumber(): Fr {
-    return this.payload.header.globalVariables.slotNumber;
-  }
-
-  get blockNumber(): Fr {
-    return this.payload.header.globalVariables.blockNumber;
+    return this.payload.header.slotNumber;
   }
 
   static async createProposalFromSigner(
+    blockNumber: Fr,
     payload: ConsensusPayload,
+    // Note(md): Provided separately to tx hashes such that this function can be optional
+    txs: Tx[] | undefined,
     payloadSigner: (payload: Buffer32) => Promise<Signature>,
   ) {
     const hashed = getHashedSignaturePayload(payload, SignatureDomainSeparator.blockProposal);
     const sig = await payloadSigner(hashed);
 
-    return new BlockProposal(payload, sig);
+    return new BlockProposal(blockNumber, payload, sig, txs);
   }
 
   /**Get Sender
@@ -85,15 +96,35 @@ export class BlockProposal extends Gossipable {
   }
 
   toBuffer(): Buffer {
-    return serializeToBuffer([this.payload, this.signature]);
+    const buffer: any[] = [this.blockNumber, this.payload, this.signature];
+    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 blockNumber = reader.readObject(Fr);
+    const payload = reader.readObject(ConsensusPayload);
+    const sig = reader.readObject(Signature);
+
+    if (!reader.isEmpty()) {
+      const txs = reader.readArray(reader.readNumber(), Tx);
+      return new BlockProposal(blockNumber, payload, sig, txs);
+    }
+
+    return new BlockProposal(blockNumber, payload, sig);
   }
 
   getSize(): number {
-    return this.payload.getSize() + this.signature.getSize();
+    return (
+      this.blockNumber.size +
+      this.payload.getSize() +
+      this.signature.getSize() +
+      (this.txs ? this.txs.reduce((acc, tx) => acc + tx.getSize(), 0) : 0)
+    );
   }
 }

package/src/p2p/consensus_payload.ts

@@ -4,22 +4,23 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { hexToBuffer } from '@aztec/foundation/string';
 import type { FieldsOf } from '@aztec/foundation/types';
 
-import { encodeAbiParameters, parseAbiParameters } from 'viem';
+import { encodeAbiParameters, parseAbiParameters, toHex } from 'viem';
 import { z } from 'zod';
 
 import type { L2Block } from '../block/l2_block.js';
-import { BlockHeader } from '../tx/block_header.js';
-import { TxHash } from '../tx/tx_hash.js';
+import { ProposedBlockHeader, StateReference, TxHash } from '../tx/index.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: ProposedBlockHeader,
+    /** The archive root after the block is added */
     public readonly archive: Fr,
+    /** The state reference after the block is added */
+    public readonly stateReference: StateReference,
     /** The sequence of transactions in the block */
     public readonly txHashes: TxHash[],
   ) {}
@@ -27,30 +28,40 @@ export class ConsensusPayload implements Signable {
   static get schema() {
     return z
       .object({
-        header: BlockHeader.schema,
+        header: ProposedBlockHeader.schema,
         archive: schemas.Fr,
+        stateReference: StateReference.schema,
         txHashes: z.array(TxHash.schema),
       })
-      .transform(obj => new ConsensusPayload(obj.header, obj.archive, obj.txHashes));
+      .transform(obj => new ConsensusPayload(obj.header, obj.archive, obj.stateReference, obj.txHashes));
   }
 
   static getFields(fields: FieldsOf<ConsensusPayload>) {
-    return [fields.header, fields.archive, fields.txHashes] as const;
+    return [fields.header, fields.archive, fields.stateReference, fields.txHashes] as const;
   }
 
   getPayloadToSign(domainSeparator: SignatureDomainSeparator): Buffer {
-    const abi = parseAbiParameters('uint8, (bytes32, (uint256), bytes, bytes32[])');
+    const abi = parseAbiParameters('uint8, (bytes32, bytes, (uint256), bytes32, bytes32[])');
+    const archiveRoot = this.archive.toString();
+    const stateReference = toHex(this.stateReference.toBuffer());
+    const headerHash = this.header.hash().toString();
     const txArray = this.txHashes.map(tx => tx.toString());
     const encodedData = encodeAbiParameters(abi, [
       domainSeparator,
-      [this.archive.toString(), [0n] /* @todo See #9963 */, this.header.toString(), txArray],
+      [archiveRoot, stateReference, [0n] /* @todo See #9963 */, headerHash, txArray],
     ] as const);
 
     return hexToBuffer(encodedData);
   }
 
   toBuffer(): Buffer {
-    const buffer = serializeToBuffer([this.header, this.archive, this.txHashes.length, this.txHashes]);
+    const buffer = serializeToBuffer([
+      this.header,
+      this.archive,
+      this.stateReference,
+      this.txHashes.length,
+      this.txHashes,
+    ]);
     this.size = buffer.length;
     return buffer;
   }
@@ -58,26 +69,28 @@ export class ConsensusPayload implements Signable {
   static fromBuffer(buf: Buffer | BufferReader): ConsensusPayload {
     const reader = BufferReader.asReader(buf);
     return new ConsensusPayload(
-      reader.readObject(BlockHeader),
+      reader.readObject(ProposedBlockHeader),
       reader.readObject(Fr),
+      reader.readObject(StateReference),
       reader.readArray(reader.readNumber(), TxHash),
     );
   }
 
   static fromFields(fields: FieldsOf<ConsensusPayload>): ConsensusPayload {
-    return new ConsensusPayload(fields.header, fields.archive, fields.txHashes);
+    return new ConsensusPayload(fields.header, fields.archive, fields.stateReference, fields.txHashes);
   }
 
   static fromBlock(block: L2Block): ConsensusPayload {
     return new ConsensusPayload(
-      block.header,
+      block.header.toPropose(),
       block.archive.root,
+      block.header.state,
       block.body.txEffects.map(tx => tx.txHash),
     );
   }
 
   static empty(): ConsensusPayload {
-    return new ConsensusPayload(BlockHeader.empty(), Fr.ZERO, []);
+    return new ConsensusPayload(ProposedBlockHeader.empty(), Fr.ZERO, StateReference.empty(), []);
   }
 
   /**
@@ -92,4 +105,8 @@ export class ConsensusPayload implements Signable {
     this.size = this.toBuffer().length;
     return this.size;
   }
+
+  toString() {
+    return `header: ${this.header.toString()}, archive: ${this.archive.toString()}, stateReference: ${this.stateReference.l1ToL2MessageTree.root.toString()}, txHashes: ${this.txHashes.join(', ')}`;
+  }
 }

package/src/p2p/gossipable.ts

@@ -1,13 +1,43 @@
-import type { Buffer32 } from '@aztec/foundation/buffer';
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { BufferReader, bigintToUInt64BE, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import type { TopicType } from './topic_type.js';
 
+export class P2PMessage {
+  constructor(
+    public readonly publishTime: Date,
+    public readonly id: Buffer32,
+    public readonly payload: Buffer,
+  ) {}
+
+  static async fromGossipable(message: Gossipable): Promise<P2PMessage> {
+    return new P2PMessage(new Date(), await message.p2pMessageIdentifier(), message.toBuffer());
+  }
+
+  static fromMessageData(messageData: Buffer): P2PMessage {
+    const reader = new BufferReader(messageData);
+    const publishTime = reader.readUInt64();
+    const id = Buffer32.fromBuffer(reader);
+    const payload = reader.readBuffer();
+    return new P2PMessage(new Date(Number(publishTime)), id, payload);
+  }
+
+  toMessageData(): Buffer {
+    return serializeToBuffer([
+      bigintToUInt64BE(BigInt(this.publishTime.getTime())),
+      this.id,
+      serializeToBuffer(this.payload.length, this.payload),
+    ]);
+  }
+}
+
 /**
  * Gossipable
  *
  * Any class which extends gossipable will be able to be Gossiped over the p2p network
  */
 export abstract class Gossipable {
+  private cachedId: Buffer32 | undefined;
   /** p2p Topic
    *
    * - The p2p topic identifier, this determines how the message is handled
@@ -18,7 +48,15 @@ export abstract class Gossipable {
    *
    *  - A digest of the message information, this key is used for deduplication
    */
-  abstract p2pMessageIdentifier(): Promise<Buffer32>;
+  async p2pMessageIdentifier(): Promise<Buffer32> {
+    if (this.cachedId) {
+      return this.cachedId;
+    }
+    this.cachedId = await this.generateP2PMessageIdentifier();
+    return this.cachedId;
+  }
+
+  abstract generateP2PMessageIdentifier(): Promise<Buffer32>;
 
   /** To Buffer
    *
@@ -26,6 +64,10 @@ export abstract class Gossipable {
    */
   abstract toBuffer(): Buffer;
 
+  toMessage(): Buffer {
+    return this.toBuffer();
+  }
+
   /**
    * Get the size of the gossipable object.
    *

package/src/p2p/topic_type.ts

@@ -22,6 +22,8 @@ export enum TopicType {
 export function getTopicTypeForClientType(clientType: P2PClientType) {
   if (clientType === P2PClientType.Full) {
     return Object.values(TopicType);
+  } else if (clientType === P2PClientType.Prover) {
+    return [TopicType.tx, TopicType.block_proposal];
   }
   return [TopicType.tx];
 }

package/src/proofs/proof.ts

@@ -1,4 +1,4 @@
-import { AGGREGATION_OBJECT_LENGTH } from '@aztec/constants';
+import { PAIRING_POINTS_SIZE } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
@@ -70,8 +70,8 @@ export class Proof {
     // We are indexing to this particular size because we are assuming the proof buffer looks like:
     // [binary public inputs, binary proof]
     // Here, we are assuming the pairing point object is the last 16 fields of the public inputs.
-    assert(this.numPublicInputs >= AGGREGATION_OBJECT_LENGTH, 'Proof does not contain an aggregation object');
-    const proofStart = Fr.SIZE_IN_BYTES * (this.numPublicInputs - AGGREGATION_OBJECT_LENGTH);
+    assert(this.numPublicInputs >= PAIRING_POINTS_SIZE, 'Proof does not contain an aggregation object');
+    const proofStart = Fr.SIZE_IN_BYTES * (this.numPublicInputs - PAIRING_POINTS_SIZE);
     assert(this.buffer.length >= proofStart, 'Proof buffer is not appropriately sized to call withoutPublicInputs()');
     return this.buffer.subarray(proofStart);
   }
@@ -84,8 +84,8 @@ export class Proof {
       // return array of this.numPublicInputs 0s
       return new Array(this.numPublicInputs).fill(Fr.zero());
     }
-    assert(this.numPublicInputs >= AGGREGATION_OBJECT_LENGTH, 'Proof does not contain an aggregation object');
-    const numInnerPublicInputs = this.numPublicInputs - AGGREGATION_OBJECT_LENGTH;
+    assert(this.numPublicInputs >= PAIRING_POINTS_SIZE, 'Proof does not contain an aggregation object');
+    const numInnerPublicInputs = this.numPublicInputs - PAIRING_POINTS_SIZE;
     const reader = BufferReader.asReader(this.buffer.subarray(0, Fr.SIZE_IN_BYTES * numInnerPublicInputs));
     const publicInputs = reader.readArray(numInnerPublicInputs, Fr);
     return publicInputs;