@aztec/stdlib 0.0.1-fake-ceab37513c → 0.0.6-commit.a2d1860fe9

package/src/p2p/signed_txs.ts

@@ -0,0 +1,88 @@
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { tryRecoverAddress } from '@aztec/foundation/crypto/secp256k1-signer';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { Signature } from '@aztec/foundation/eth-signature';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { MAX_TXS_PER_BLOCK } from '../deserialization/index.js';
+import { Tx } from '../tx/tx.js';
+import {
+  SignatureDomainSeparator,
+  getHashedSignaturePayload,
+  getHashedSignaturePayloadEthSignedMessage,
+} from './signature_utils.js';
+
+/**
+ * A signed collection of transactions.
+ * The signature is over the transaction objects themselves, providing
+ * data availability guarantees beyond just the transaction hashes.
+ */
+export class SignedTxs {
+  private sender: EthAddress | undefined;
+
+  constructor(
+    /** The transactions */
+    public readonly txs: Tx[],
+    /** The proposer's signature over the transactions */
+    public readonly signature: Signature,
+  ) {}
+
+  /**
+   * Get the payload to sign for this signed txs.
+   */
+  getPayloadToSign(domainSeparator: SignatureDomainSeparator): Buffer {
+    return serializeToBuffer([domainSeparator, this.txs.length, this.txs]);
+  }
+
+  /**
+   * Lazily evaluate the sender of the signed txs; result is cached
+   * @returns The sender address, or undefined if signature recovery fails
+   */
+  getSender(): EthAddress | undefined {
+    if (!this.sender) {
+      const hashed = getHashedSignaturePayloadEthSignedMessage(this, SignatureDomainSeparator.signedTxs);
+      this.sender = tryRecoverAddress(hashed, this.signature);
+    }
+    return this.sender;
+  }
+
+  /**
+   * Create SignedTxs from a signer function
+   */
+  static async createFromSigner(
+    txs: Tx[],
+    payloadSigner: (payload: Buffer32) => Promise<Signature>,
+  ): Promise<SignedTxs> {
+    const tempSignedTxs = new SignedTxs(txs, Signature.empty());
+    const hashed = getHashedSignaturePayload(tempSignedTxs, SignatureDomainSeparator.signedTxs);
+    const signature = await payloadSigner(hashed);
+    return new SignedTxs(txs, signature);
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer([this.txs.length, this.txs, this.signature]);
+  }
+
+  static fromBuffer(buf: Buffer | BufferReader): SignedTxs {
+    const reader = BufferReader.asReader(buf);
+    const txCount = reader.readNumber();
+    if (txCount > MAX_TXS_PER_BLOCK) {
+      throw new Error(`txs count ${txCount} exceeds maximum ${MAX_TXS_PER_BLOCK}`);
+    }
+    const txs = reader.readArray(txCount, Tx);
+    const signature = reader.readObject(Signature);
+    return new SignedTxs(txs, signature);
+  }
+
+  getSize(): number {
+    return 4 /* txs.length */ + this.txs.reduce((acc, tx) => acc + tx.getSize(), 0) + this.signature.getSize();
+  }
+
+  static empty(): SignedTxs {
+    return new SignedTxs([], Signature.empty());
+  }
+
+  static random(): SignedTxs {
+    return new SignedTxs([Tx.random(), Tx.random()], Signature.random());
+  }
+}

package/src/p2p/topic_type.ts

@@ -23,14 +23,15 @@ export function getTopicFromString(topicStr: string): TopicType | undefined {
 export enum TopicType {
   tx = 'tx',
   block_proposal = 'block_proposal',
-  block_attestation = 'block_attestation',
+  checkpoint_proposal = 'checkpoint_proposal',
+  checkpoint_attestation = 'checkpoint_attestation',
 }
 
 export function getTopicTypeForClientType(clientType: P2PClientType) {
   if (clientType === P2PClientType.Full) {
-    return Object.values(TopicType);
+    return [TopicType.tx, TopicType.block_proposal, TopicType.checkpoint_proposal, TopicType.checkpoint_attestation];
   } else if (clientType === P2PClientType.Prover) {
-    return [TopicType.tx, TopicType.block_proposal];
+    return [TopicType.tx, TopicType.block_proposal, TopicType.checkpoint_proposal];
   } else {
     const _: never = clientType;
     return [TopicType.tx];

package/src/parity/index.ts

@@ -1,4 +1,3 @@
-export * from './base_parity_inputs.js';
+export * from './parity_base_private_inputs.js';
 export * from './parity_public_inputs.js';
-export * from './root_parity_input.js';
-export * from './root_parity_inputs.js';
+export * from './parity_root_private_inputs.js';

package/src/parity/{base_parity_inputs.ts → parity_base_private_inputs.ts}

@@ -1,10 +1,10 @@
-import { type NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, NUM_MSGS_PER_BASE_PARITY } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, NUM_MSGS_PER_BASE_PARITY } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
-export class BaseParityInputs {
+export class ParityBasePrivateInputs {
   constructor(
     /** Aggregated proof of all the parity circuit iterations. */
     public readonly msgs: Tuple<Fr, typeof NUM_MSGS_PER_BASE_PARITY>,
@@ -12,15 +12,17 @@ export class BaseParityInputs {
     public readonly vkTreeRoot: Fr,
   ) {}
 
-  public static fromSlice(
-    array: Tuple<Fr, typeof NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP>,
-    index: number,
-    vkTreeRoot: Fr,
-  ): BaseParityInputs {
+  public static fromSlice(array: Fr[], index: number, vkTreeRoot: Fr): ParityBasePrivateInputs {
+    // Can't use Tuple<Fr, typeof NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP> due to length
+    if (array.length !== NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP) {
+      throw new Error(
+        `Msgs array length must be NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP=${NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP}`,
+      );
+    }
     const start = index * NUM_MSGS_PER_BASE_PARITY;
     const end = start + NUM_MSGS_PER_BASE_PARITY;
     const msgs = array.slice(start, end);
-    return new BaseParityInputs(msgs as Tuple<Fr, typeof NUM_MSGS_PER_BASE_PARITY>, vkTreeRoot);
+    return new ParityBasePrivateInputs(msgs as Tuple<Fr, typeof NUM_MSGS_PER_BASE_PARITY>, vkTreeRoot);
   }
 
   /** Serializes the inputs to a buffer. */
@@ -39,7 +41,7 @@ export class BaseParityInputs {
    */
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    return new BaseParityInputs(reader.readArray(NUM_MSGS_PER_BASE_PARITY, Fr), Fr.fromBuffer(reader));
+    return new ParityBasePrivateInputs(reader.readArray(NUM_MSGS_PER_BASE_PARITY, Fr), Fr.fromBuffer(reader));
   }
 
   /**
@@ -48,7 +50,7 @@ export class BaseParityInputs {
    * @returns - The deserialized inputs.
    */
   static fromString(str: string) {
-    return BaseParityInputs.fromBuffer(hexToBuffer(str));
+    return ParityBasePrivateInputs.fromBuffer(hexToBuffer(str));
   }
 
   /** Returns a buffer representation for JSON serialization. */
@@ -58,6 +60,6 @@ export class BaseParityInputs {
 
   /** Creates an instance from a hex string. */
   static get schema() {
-    return bufferSchemaFor(BaseParityInputs);
+    return bufferSchemaFor(ParityBasePrivateInputs);
   }
 }

package/src/parity/parity_public_inputs.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';

package/src/parity/{root_parity_inputs.ts → parity_root_private_inputs.ts}

@@ -1,17 +1,18 @@
-import { NUM_BASE_PARITY_PER_ROOT_PARITY, RECURSIVE_PROOF_LENGTH } from '@aztec/constants';
+import { NUM_BASE_PARITY_PER_ROOT_PARITY } from '@aztec/constants';
+import { makeTuple } from '@aztec/foundation/array';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
-import { RootParityInput } from './root_parity_input.js';
+import { ProofData, type UltraHonkProofData } from '../proofs/proof_data.js';
+import { ParityPublicInputs } from './parity_public_inputs.js';
 
-export class RootParityInputs {
+export type ParityBaseProofData = UltraHonkProofData<ParityPublicInputs>;
+
+export class ParityRootPrivateInputs {
   constructor(
-    /** Public inputs of children and their proofs. */
-    public readonly children: Tuple<
-      RootParityInput<typeof RECURSIVE_PROOF_LENGTH>,
-      typeof NUM_BASE_PARITY_PER_ROOT_PARITY
-    >,
+    /** Public inputs of the parity base circuits and their proofs and vk data. */
+    public readonly children: Tuple<ParityBaseProofData, typeof NUM_BASE_PARITY_PER_ROOT_PARITY>,
   ) {}
 
   /**
@@ -19,7 +20,7 @@ export class RootParityInputs {
    * @returns The inputs serialized to a buffer.
    */
   toBuffer() {
-    return serializeToBuffer(...this.children);
+    return serializeToBuffer(this.children);
   }
 
   /**
@@ -33,25 +34,22 @@ export class RootParityInputs {
   /**
    * Deserializes the inputs from a buffer.
    * @param buffer - The buffer to deserialize from.
-   * @returns A new RootParityInputs instance.
+   * @returns A new ParityRootPrivateInputs instance.
    */
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
-    const tuple = Array.from({ length: NUM_BASE_PARITY_PER_ROOT_PARITY }, () =>
-      RootParityInput.fromBuffer(reader, RECURSIVE_PROOF_LENGTH),
-    );
-    return new RootParityInputs(
-      tuple as Tuple<RootParityInput<typeof RECURSIVE_PROOF_LENGTH>, typeof NUM_BASE_PARITY_PER_ROOT_PARITY>,
+    return new ParityRootPrivateInputs(
+      makeTuple(NUM_BASE_PARITY_PER_ROOT_PARITY, () => ProofData.fromBuffer(reader, ParityPublicInputs)),
     );
   }
 
   /**
    * Deserializes the inputs from a hex string.
    * @param str - A hex string to deserialize from.
-   * @returns A new RootParityInputs instance.
+   * @returns A new ParityRootPrivateInputs instance.
    */
   static fromString(str: string) {
-    return RootParityInputs.fromBuffer(hexToBuffer(str));
+    return ParityRootPrivateInputs.fromBuffer(hexToBuffer(str));
   }
 
   /** Returns a buffer representation for JSON serialization. */
@@ -61,6 +59,6 @@ export class RootParityInputs {
 
   /** Creates an instance from a hex string. */
   static get schema() {
-    return bufferSchemaFor(RootParityInputs);
+    return bufferSchemaFor(ParityRootPrivateInputs);
   }
 }

package/src/proofs/chonk_proof.ts

@@ -0,0 +1,122 @@
+import { CHONK_PROOF_LENGTH } from '@aztec/constants';
+import { times } from '@aztec/foundation/collection';
+import { randomBytes } from '@aztec/foundation/crypto/random';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import { bufferSchemaFor } from '@aztec/foundation/schemas';
+import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
+
+// CHONK: "Client Honk" - An UltraHonk variant with incremental folding and delayed non-native arithmetic.
+export class ChonkProof {
+  constructor(
+    // The proof fields.
+    // For native verification, attach public inputs via `attachPublicInputs(publicInputs)`.
+    // Not using Tuple here due to the length being too high.
+    public fields: Fr[],
+  ) {
+    if (fields.length !== CHONK_PROOF_LENGTH) {
+      throw new Error(`Invalid ChonkProof length: ${fields.length}`);
+    }
+  }
+
+  public attachPublicInputs(publicInputs: Fr[]) {
+    return new ChonkProofWithPublicInputs([...publicInputs, ...this.fields]);
+  }
+
+  public isEmpty() {
+    return this.fields.every(field => field.isZero());
+  }
+
+  static empty() {
+    return new ChonkProof(new Array(CHONK_PROOF_LENGTH).fill(Fr.ZERO));
+  }
+
+  static random() {
+    // NB: Not using Fr.random here because it slows down some tests that require a large number of txs significantly.
+    // NB2: generate one fewer random bytes to not have to deal with buffers representing numbers greater than the field modulus
+    // NB3: a chonk proof can be compressed. Simulate this by filling 1/4 of the proof with zero data
+    const reducedFrSize = Fr.SIZE_IN_BYTES - 1;
+    const nonZeroFields = Math.floor((3 * CHONK_PROOF_LENGTH) / 4);
+    const randomFields = randomBytes(nonZeroFields * Fr.SIZE_IN_BYTES);
+    const proof = [
+      ...times(nonZeroFields, i => new Fr(randomFields.subarray(i * reducedFrSize, (i + 1) * reducedFrSize))),
+      ...times(CHONK_PROOF_LENGTH - nonZeroFields, () => Fr.ZERO),
+    ];
+    return new ChonkProof(proof);
+  }
+
+  static get schema() {
+    return bufferSchemaFor(ChonkProof);
+  }
+
+  // We use this in tandem with the bufferSchemaFor to serialize to base64 strings.
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): ChonkProof {
+    const reader = BufferReader.asReader(buffer);
+    const proofLength = reader.readNumber();
+    const proof = reader.readArray(proofLength, Fr);
+    return new ChonkProof(proof);
+  }
+
+  public toBuffer() {
+    return serializeToBuffer(this.fields.length, this.fields);
+  }
+}
+
+export class ChonkProofWithPublicInputs {
+  constructor(
+    // The proof fields with public inputs.
+    // For recursive verification, use without public inputs via `removePublicInputs()`.
+    public fieldsWithPublicInputs: Fr[],
+  ) {
+    if (fieldsWithPublicInputs.length < CHONK_PROOF_LENGTH) {
+      throw new Error(`Invalid ChonkProofWithPublicInputs length: ${fieldsWithPublicInputs.length}`);
+    }
+  }
+
+  public getPublicInputs() {
+    const numPublicInputs = this.fieldsWithPublicInputs.length - CHONK_PROOF_LENGTH;
+    return this.fieldsWithPublicInputs.slice(0, numPublicInputs);
+  }
+
+  public removePublicInputs() {
+    const numPublicInputs = this.fieldsWithPublicInputs.length - CHONK_PROOF_LENGTH;
+    return new ChonkProof(this.fieldsWithPublicInputs.slice(numPublicInputs));
+  }
+
+  public isEmpty() {
+    return this.fieldsWithPublicInputs.every(field => field.isZero());
+  }
+
+  static empty() {
+    return ChonkProof.empty().attachPublicInputs([]);
+  }
+
+  static get schema() {
+    return bufferSchemaFor(ChonkProofWithPublicInputs);
+  }
+
+  // We use this in tandem with the bufferSchemaFor to serialize to base64 strings.
+  toJSON() {
+    return this.toBuffer();
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): ChonkProofWithPublicInputs {
+    const reader = BufferReader.asReader(buffer);
+    const proofLength = reader.readNumber();
+    const proof = reader.readArray(proofLength, Fr);
+    return new ChonkProofWithPublicInputs(proof);
+  }
+
+  public toBuffer() {
+    return serializeToBuffer(this.fieldsWithPublicInputs.length, this.fieldsWithPublicInputs);
+  }
+
+  // Called when constructing from bb proving results.
+  static fromBufferArray(fields: Uint8Array[]): ChonkProofWithPublicInputs {
+    const proof = fields.map(field => Fr.fromBuffer(Buffer.from(field)));
+    return new ChonkProofWithPublicInputs(proof);
+  }
+}

package/src/proofs/index.ts

@@ -1,4 +1,5 @@
 export * from './recursive_proof.js';
-export * from './client_ivc_proof.js';
+export * from './chonk_proof.js';
 export * from './proof.js';
+export * from './proof_data.js';
 export * from './proving_request_type.js';

package/src/proofs/proof.ts

@@ -1,5 +1,5 @@
 import { PAIRING_POINTS_SIZE } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 

package/src/proofs/proof_data.ts

@@ -0,0 +1,60 @@
+import type { CHONK_PROOF_LENGTH, RECURSIVE_PROOF_LENGTH, RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants';
+import { BufferReader, type Bufferable, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import { RecursiveProof } from '../proofs/recursive_proof.js';
+import { VkData } from '../vks/index.js';
+
+/**
+ * Represents the data of a recursive proof.
+ */
+export class ProofData<T extends Bufferable, PROOF_LENGTH extends number> {
+  constructor(
+    public publicInputs: T,
+    public proof: RecursiveProof<PROOF_LENGTH>,
+    public vkData: VkData,
+  ) {}
+
+  public toBuffer(): Buffer {
+    return serializeToBuffer(this.publicInputs, this.proof, this.vkData);
+  }
+
+  public static fromBuffer<T extends Bufferable, PROOF_LENGTH extends number>(
+    buffer: Buffer | BufferReader,
+    publicInputs: {
+      fromBuffer: (reader: BufferReader) => T;
+    },
+  ): ProofData<T, PROOF_LENGTH> {
+    const reader = BufferReader.asReader(buffer);
+    return new ProofData(reader.readObject(publicInputs), RecursiveProof.fromBuffer(reader), reader.readObject(VkData));
+  }
+}
+
+/**
+ * Represents the data of a recursive proof for a circuit with a fixed verification key.
+ */
+export class ProofDataForFixedVk<T extends Bufferable, PROOF_LENGTH extends number> {
+  constructor(
+    public publicInputs: T,
+    public proof: RecursiveProof<PROOF_LENGTH>,
+  ) {}
+
+  public toBuffer(): Buffer {
+    return serializeToBuffer(this.publicInputs, this.proof);
+  }
+
+  public static fromBuffer<T extends Bufferable, PROOF_LENGTH extends number>(
+    buffer: Buffer | BufferReader,
+    publicInputs: {
+      fromBuffer: (reader: BufferReader) => T;
+    },
+  ): ProofDataForFixedVk<T, PROOF_LENGTH> {
+    const reader = BufferReader.asReader(buffer);
+    return new ProofDataForFixedVk(reader.readObject(publicInputs), RecursiveProof.fromBuffer(reader));
+  }
+}
+
+export type ChonkProofData<T extends Bufferable> = ProofData<T, typeof CHONK_PROOF_LENGTH>;
+
+export type UltraHonkProofData<T extends Bufferable> = ProofData<T, typeof RECURSIVE_PROOF_LENGTH>;
+
+export type RollupHonkProofData<T extends Bufferable> = ProofData<T, typeof RECURSIVE_ROLLUP_HONK_PROOF_LENGTH>;

package/src/proofs/proving_request_type.ts

@@ -1,18 +1,22 @@
 export enum ProvingRequestType {
   PUBLIC_VM,
+  PUBLIC_CHONK_VERIFIER,
 
-  PRIVATE_BASE_ROLLUP,
-  PUBLIC_BASE_ROLLUP,
-  MERGE_ROLLUP,
-  EMPTY_BLOCK_ROOT_ROLLUP,
-  PADDING_BLOCK_ROOT_ROLLUP,
+  PRIVATE_TX_BASE_ROLLUP,
+  PUBLIC_TX_BASE_ROLLUP,
+  TX_MERGE_ROLLUP,
+  BLOCK_ROOT_FIRST_ROLLUP,
+  BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP,
+  BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP,
   BLOCK_ROOT_ROLLUP,
-  SINGLE_TX_BLOCK_ROOT_ROLLUP,
+  BLOCK_ROOT_SINGLE_TX_ROLLUP,
   BLOCK_MERGE_ROLLUP,
+  CHECKPOINT_ROOT_ROLLUP,
+  CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP,
+  CHECKPOINT_PADDING_ROLLUP,
+  CHECKPOINT_MERGE_ROLLUP,
   ROOT_ROLLUP,
 
-  BASE_PARITY,
-  ROOT_PARITY,
-  /** Recursive Client IVC verification to connect private to public or rollup */
-  TUBE_PROOF,
+  PARITY_BASE,
+  PARITY_ROOT,
 }

package/src/proofs/recursive_proof.ts

@@ -1,5 +1,5 @@
 import { makeTuple } from '@aztec/foundation/array';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';

package/src/rollup/avm_proof_data.ts

@@ -1,42 +1,6 @@
 import { AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
-import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { AvmCircuitPublicInputs } from '../avm/avm_circuit_public_inputs.js';
-import { RecursiveProof, makeEmptyRecursiveProof } from '../proofs/recursive_proof.js';
-import { VkData } from '../vks/vk_data.js';
+import type { ProofDataForFixedVk } from '../proofs/proof_data.js';
 
-export class AvmProofData {
-  constructor(
-    public publicInputs: AvmCircuitPublicInputs,
-    public proof: RecursiveProof<typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>,
-    public vkData: VkData,
-  ) {}
-
-  static fromBuffer(buffer: Buffer | BufferReader) {
-    const reader = BufferReader.asReader(buffer);
-    return new AvmProofData(
-      reader.readObject(AvmCircuitPublicInputs),
-      RecursiveProof.fromBuffer(reader),
-      reader.readObject(VkData),
-    );
-  }
-
-  toBuffer() {
-    return serializeToBuffer(this.publicInputs, this.proof, this.vkData);
-  }
-
-  static empty() {
-    return new AvmProofData(
-      AvmCircuitPublicInputs.empty(),
-      makeEmptyRecursiveProof(AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED),
-      VkData.empty(),
-    );
-  }
-}
-
-// TODO(#14234)[Unconditional PIs validation]: remove this function.
-export function enhanceProofWithPiValidationFlag(proof: Fr[], skipPublicInputsValidation: boolean): Fr[] {
-  const skipPublicInputsField = skipPublicInputsValidation ? new Fr(1) : new Fr(0);
-  return [skipPublicInputsField].concat(proof).slice(0, AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED);
-}
+export type AvmProofData = ProofDataForFixedVk<AvmCircuitPublicInputs, typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>;

package/src/rollup/base_rollup_hints.ts

@@ -1,17 +1,17 @@
-import { SpongeBlob } from '@aztec/blob-lib';
+import { SpongeBlob } from '@aztec/blob-lib/types';
 import { ARCHIVE_HEIGHT, MAX_CONTRACT_CLASS_LOGS_PER_TX } from '@aztec/constants';
 import { makeTuple } from '@aztec/foundation/array';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
-import { MembershipWitness } from '@aztec/foundation/trees';
 import type { FieldsOf } from '@aztec/foundation/types';
 
-import { PublicDataHint } from '../avm/public_data_hint.js';
 import { ContractClassLogFields } from '../logs/index.js';
-import { AppendOnlyTreeSnapshot } from '../trees/index.js';
+import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
+import { PublicDataTreeLeafPreimage } from '../trees/public_data_leaf.js';
 import { PartialStateReference } from '../tx/partial_state_reference.js';
 import { BlockConstantData } from './block_constant_data.js';
-import { PrivateBaseStateDiffHints } from './state_diff_hints.js';
+import { TreeSnapshotDiffHints } from './tree_snapshot_diff_hints.js';
 
 export type BaseRollupHints = PrivateBaseRollupHints | PublicBaseRollupHints;
 
@@ -28,15 +28,15 @@ export class PrivateBaseRollupHints {
     /**
      * Hints used while proving state diff validity.
      */
-    public stateDiffHints: PrivateBaseStateDiffHints,
+    public treeSnapshotDiffHints: TreeSnapshotDiffHints,
     /**
-     * Public data read hint for accessing the balance of the fee payer.
+     * Public data tree leaf preimage for accessing the balance of the fee payer.
      */
-    public feePayerFeeJuiceBalanceReadHint: PublicDataHint,
+    public feePayerBalanceLeafPreimage: PublicDataTreeLeafPreimage,
     /**
      * Membership witnesses of blocks referred by each of the 2 kernels.
      */
-    public archiveRootMembershipWitness: MembershipWitness<typeof ARCHIVE_HEIGHT>,
+    public anchorBlockArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
     /**
      * Preimages to the kernel's contractClassLogsHashes.
      */
@@ -55,9 +55,9 @@ export class PrivateBaseRollupHints {
     return [
       fields.start,
       fields.startSpongeBlob,
-      fields.stateDiffHints,
-      fields.feePayerFeeJuiceBalanceReadHint,
-      fields.archiveRootMembershipWitness,
+      fields.treeSnapshotDiffHints,
+      fields.feePayerBalanceLeafPreimage,
+      fields.anchorBlockArchiveSiblingPath,
       fields.contractClassLogsFields,
       fields.constants,
     ] as const;
@@ -84,9 +84,9 @@ export class PrivateBaseRollupHints {
     return new PrivateBaseRollupHints(
       reader.readObject(PartialStateReference),
       reader.readObject(SpongeBlob),
-      reader.readObject(PrivateBaseStateDiffHints),
-      reader.readObject(PublicDataHint),
-      MembershipWitness.fromBuffer(reader, ARCHIVE_HEIGHT),
+      reader.readObject(TreeSnapshotDiffHints),
+      reader.readObject(PublicDataTreeLeafPreimage),
+      reader.readArray(ARCHIVE_HEIGHT, Fr),
       makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, () => reader.readObject(ContractClassLogFields)),
       reader.readObject(BlockConstantData),
     );
@@ -100,9 +100,9 @@ export class PrivateBaseRollupHints {
     return new PrivateBaseRollupHints(
       PartialStateReference.empty(),
       SpongeBlob.empty(),
-      PrivateBaseStateDiffHints.empty(),
-      PublicDataHint.empty(),
-      MembershipWitness.empty(ARCHIVE_HEIGHT),
+      TreeSnapshotDiffHints.empty(),
+      PublicDataTreeLeafPreimage.empty(),
+      makeTuple(ARCHIVE_HEIGHT, Fr.zero),
       makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLogFields.empty),
       BlockConstantData.empty(),
     );
@@ -122,7 +122,7 @@ export class PublicBaseRollupHints {
     /**
      * Membership witnesses of blocks referred by each of the 2 kernels.
      */
-    public archiveRootMembershipWitness: MembershipWitness<typeof ARCHIVE_HEIGHT>,
+    public anchorBlockArchiveSiblingPath: Tuple<Fr, typeof ARCHIVE_HEIGHT>,
     /**
      * Preimages to the kernel's contractClassLogsHashes.
      */
@@ -137,7 +137,7 @@ export class PublicBaseRollupHints {
     return [
       fields.startSpongeBlob,
       fields.lastArchive,
-      fields.archiveRootMembershipWitness,
+      fields.anchorBlockArchiveSiblingPath,
       fields.contractClassLogsFields,
     ] as const;
   }
@@ -163,7 +163,7 @@ export class PublicBaseRollupHints {
     return new PublicBaseRollupHints(
       reader.readObject(SpongeBlob),
       reader.readObject(AppendOnlyTreeSnapshot),
-      MembershipWitness.fromBuffer(reader, ARCHIVE_HEIGHT),
+      reader.readArray(ARCHIVE_HEIGHT, Fr),
       makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, () => reader.readObject(ContractClassLogFields)),
     );
   }
@@ -176,7 +176,7 @@ export class PublicBaseRollupHints {
     return new PublicBaseRollupHints(
       SpongeBlob.empty(),
       AppendOnlyTreeSnapshot.empty(),
-      MembershipWitness.empty(ARCHIVE_HEIGHT),
+      makeTuple(ARCHIVE_HEIGHT, Fr.zero),
       makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, ContractClassLogFields.empty),
     );
   }