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

package/src/tests/mocks.ts

@@ -6,13 +6,15 @@ import { Fr } from '@aztec/foundation/fields';
 
 import type { ContractArtifact } from '../abi/abi.js';
 import { AztecAddress } from '../aztec-address/index.js';
-import { CommitteeAttestation } from '../block/index.js';
+import { CommitteeAttestation, L1PublishedData, L2BlockHeader } from '../block/index.js';
 import { L2Block } from '../block/l2_block.js';
-import type { PublishedL2Block } from '../block/published_l2_block.js';
+import type { CommitteeAttestationsAndSigners } from '../block/proposal/attestations_and_signers.js';
+import { PublishedL2Block } from '../block/published_l2_block.js';
 import { computeContractAddressFromInstance } from '../contract/contract_address.js';
 import { getContractClassFromArtifact } from '../contract/contract_class.js';
 import { SerializableContractInstance } from '../contract/contract_instance.js';
 import type { ContractInstanceWithAddress } from '../contract/index.js';
+import { Gas } from '../gas/gas.js';
 import { GasFees } from '../gas/gas_fees.js';
 import { GasSettings } from '../gas/gas_settings.js';
 import { Nullifier } from '../kernel/nullifier.js';
@@ -22,45 +24,22 @@ import {
   PrivateKernelTailCircuitPublicInputs,
 } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
 import { PrivateToPublicAccumulatedDataBuilder } from '../kernel/private_to_public_accumulated_data_builder.js';
-import { ExtendedNote, UniqueNote } from '../note/extended_note.js';
 import { Note } from '../note/note.js';
+import { UniqueNote } from '../note/unique_note.js';
 import { BlockAttestation } from '../p2p/block_attestation.js';
 import { BlockProposal } from '../p2p/block_proposal.js';
 import { ConsensusPayload } from '../p2p/consensus_payload.js';
 import { SignatureDomainSeparator, getHashedSignaturePayloadEthSignedMessage } from '../p2p/signature_utils.js';
-import { ClientIvcProof } from '../proofs/client_ivc_proof.js';
-import {
-  BlockHeader,
-  HashedValues,
-  PrivateCallExecutionResult,
-  PrivateExecutionResult,
-  StateReference,
-  Tx,
-} from '../tx/index.js';
+import { ChonkProof } from '../proofs/chonk_proof.js';
+import { HashedValues, PrivateCallExecutionResult, PrivateExecutionResult, StateReference, Tx } from '../tx/index.js';
 import { PublicSimulationOutput } from '../tx/public_simulation_output.js';
 import { TxSimulationResult, accumulatePrivateReturnValues } from '../tx/simulated_tx.js';
 import { TxEffect } from '../tx/tx_effect.js';
 import { TxHash } from '../tx/tx_hash.js';
-import { makeGas, makeGlobalVariables, makeHeader, makePublicCallRequest } from './factories.js';
+import { makeGas, makeGlobalVariables, makeL2BlockHeader, makePublicCallRequest } from './factories.js';
 
 export const randomTxHash = (): TxHash => TxHash.random();
 
-export const randomExtendedNote = async ({
-  note = Note.random(),
-  recipient = undefined,
-  contractAddress = undefined,
-  txHash = randomTxHash(),
-  storageSlot = Fr.random(),
-}: Partial<ExtendedNote> = {}) => {
-  return new ExtendedNote(
-    note,
-    recipient ?? (await AztecAddress.random()),
-    contractAddress ?? (await AztecAddress.random()),
-    storageSlot,
-    txHash,
-  );
-};
-
 export const randomUniqueNote = async ({
   note = Note.random(),
   recipient = undefined,
@@ -88,12 +67,13 @@ export const mockTx = async (
     hasPublicTeardownCallRequest = false,
     publicCalldataSize = 2,
     feePayer,
-    clientIvcProof = ClientIvcProof.empty(),
+    chonkProof = ChonkProof.random(),
     maxPriorityFeesPerGas,
+    gasUsed = Gas.empty(),
     chainId = Fr.ZERO,
     version = Fr.ZERO,
     vkTreeRoot = Fr.ZERO,
-    protocolContractTreeRoot = Fr.ZERO,
+    protocolContractsHash = Fr.ZERO,
   }: {
     numberOfNonRevertiblePublicCallRequests?: number;
     numberOfRevertiblePublicCallRequests?: number;
@@ -101,12 +81,13 @@ export const mockTx = async (
     hasPublicTeardownCallRequest?: boolean;
     publicCalldataSize?: number;
     feePayer?: AztecAddress;
-    clientIvcProof?: ClientIvcProof;
+    chonkProof?: ChonkProof;
     maxPriorityFeesPerGas?: GasFees;
+    gasUsed?: Gas;
     chainId?: Fr;
     version?: Fr;
     vkTreeRoot?: Fr;
-    protocolContractTreeRoot?: Fr;
+    protocolContractsHash?: Fr;
   } = {},
 ) => {
   const totalPublicCallRequests =
@@ -115,16 +96,17 @@ export const mockTx = async (
     (hasPublicTeardownCallRequest ? 1 : 0);
   const isForPublic = totalPublicCallRequests > 0;
   const data = PrivateKernelTailCircuitPublicInputs.empty();
-  const firstNullifier = new Nullifier(new Fr(seed + 1), 0, Fr.ZERO);
+  const firstNullifier = new Nullifier(new Fr(seed + 1), Fr.ZERO, 0);
   data.constants.txContext.gasSettings = GasSettings.default({
     maxFeesPerGas: new GasFees(10, 10),
     maxPriorityFeesPerGas,
   });
   data.feePayer = feePayer ?? (await AztecAddress.random());
+  data.gasUsed = gasUsed;
   data.constants.txContext.chainId = chainId;
   data.constants.txContext.version = version;
   data.constants.vkTreeRoot = vkTreeRoot;
-  data.constants.protocolContractTreeRoot = protocolContractTreeRoot;
+  data.constants.protocolContractsHash = protocolContractsHash;
 
   // Set includeByTimestamp to the maximum allowed duration from the current time.
   data.includeByTimestamp = BigInt(Math.floor(Date.now() / 1000) + MAX_INCLUDE_BY_TIMESTAMP_DURATION);
@@ -157,7 +139,7 @@ export const mockTx = async (
       .build();
 
     for (let i = 0; i < numberOfRevertibleNullifiers; i++) {
-      const revertibleNullifier = new Nullifier(new Fr(seed + 2 + i), 0, Fr.ZERO);
+      const revertibleNullifier = new Nullifier(new Fr(seed + 2 + i), Fr.ZERO, 0);
       revertibleBuilder.pushNullifier(revertibleNullifier.value);
     }
 
@@ -168,7 +150,7 @@ export const mockTx = async (
 
   return await Tx.create({
     data,
-    clientIvcProof,
+    chonkProof,
     contractClassLogFields: [],
     publicFunctionCalldata,
   });
@@ -190,6 +172,7 @@ const emptyPrivateCallExecutionResult = () =>
     [],
     [],
     [],
+    [],
   );
 
 const emptyPrivateExecutionResult = () => new PrivateExecutionResult(emptyPrivateCallExecutionResult(), Fr.zero(), []);
@@ -247,7 +230,9 @@ export const randomDeployedContract = async () => {
 
 export interface MakeConsensusPayloadOptions {
   signer?: Secp256k1Signer;
-  header?: BlockHeader;
+  attesterSigner?: Secp256k1Signer;
+  proposerSigner?: Secp256k1Signer;
+  header?: L2BlockHeader;
   archive?: Fr;
   stateReference?: StateReference;
   txHashes?: TxHash[];
@@ -258,11 +243,11 @@ const makeAndSignConsensusPayload = (
   domainSeparator: SignatureDomainSeparator,
   options?: MakeConsensusPayloadOptions,
 ) => {
-  const header = options?.header ?? makeHeader(1);
+  const header = options?.header ?? makeL2BlockHeader(1);
   const { signer = Secp256k1Signer.random(), archive = Fr.random(), stateReference = header.state } = options ?? {};
 
   const payload = ConsensusPayload.fromFields({
-    header: header.toPropose(),
+    header: header.toCheckpointHeader(),
     archive,
     stateReference,
   });
@@ -273,32 +258,77 @@ const makeAndSignConsensusPayload = (
   return { blockNumber: header.globalVariables.blockNumber, payload, signature };
 };
 
-export const makeBlockProposal = (options?: MakeConsensusPayloadOptions): BlockProposal => {
-  const { blockNumber, payload, signature } = makeAndSignConsensusPayload(
-    SignatureDomainSeparator.blockProposal,
-    options,
+export const makeAndSignCommitteeAttestationsAndSigners = (
+  attestationsAndSigners: CommitteeAttestationsAndSigners,
+  signer: Secp256k1Signer = Secp256k1Signer.random(),
+) => {
+  const hash = getHashedSignaturePayloadEthSignedMessage(
+    attestationsAndSigners,
+    SignatureDomainSeparator.attestationsAndSigners,
   );
+  return signer.sign(hash);
+};
+
+export const makeBlockProposal = (options?: MakeConsensusPayloadOptions): BlockProposal => {
+  const { payload, signature } = makeAndSignConsensusPayload(SignatureDomainSeparator.blockProposal, options);
   const txHashes = options?.txHashes ?? [0, 1, 2, 3, 4, 5].map(() => TxHash.random());
-  return new BlockProposal(blockNumber, payload, signature, txHashes, options?.txs ?? []);
+  return new BlockProposal(payload, signature, txHashes, options?.txs ?? []);
 };
 
 // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8028)
 export const makeBlockAttestation = (options?: MakeConsensusPayloadOptions): BlockAttestation => {
-  const { blockNumber, payload, signature } = makeAndSignConsensusPayload(
-    SignatureDomainSeparator.blockAttestation,
-    options,
-  );
-  return new BlockAttestation(blockNumber, payload, signature);
+  const header = options?.header ?? makeL2BlockHeader(1);
+  const {
+    signer,
+    attesterSigner = signer ?? Secp256k1Signer.random(),
+    proposerSigner = signer ?? Secp256k1Signer.random(),
+    archive = Fr.random(),
+    stateReference = header.state,
+  } = options ?? {};
+
+  const payload = ConsensusPayload.fromFields({
+    header: header.toCheckpointHeader(),
+    archive,
+    stateReference,
+  });
+
+  // Sign as attester
+  const attestationHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
+  const attestationSignature = attesterSigner.sign(attestationHash);
+
+  // Sign as proposer
+  const proposalHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockProposal);
+  const proposerSignature = proposerSigner.sign(proposalHash);
+
+  return new BlockAttestation(payload, attestationSignature, proposerSignature);
 };
 
-export const makeBlockAttestationFromBlock = (block: L2Block, signer?: Secp256k1Signer): BlockAttestation => {
-  return makeBlockAttestation({
-    signer,
-    header: block.header,
-    archive: block.archive.root,
-    stateReference: block.header.state,
-    txHashes: block.body.txEffects.map(tx => tx.txHash),
+export const makeBlockAttestationFromBlock = (
+  block: L2Block,
+  attesterSigner?: Secp256k1Signer,
+  proposerSigner?: Secp256k1Signer,
+): BlockAttestation => {
+  const header = block.header;
+  const archive = block.archive.root;
+  const stateReference = block.header.state;
+
+  const payload = ConsensusPayload.fromFields({
+    header: header.toCheckpointHeader(),
+    archive,
+    stateReference,
   });
+
+  // Sign as attester
+  const attestationHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
+  const attestationSigner = attesterSigner ?? Secp256k1Signer.random();
+  const attestationSignature = attestationSigner.sign(attestationHash);
+
+  // Sign as proposer
+  const proposalHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockProposal);
+  const proposalSignerToUse = proposerSigner ?? Secp256k1Signer.random();
+  const proposerSignature = proposalSignerToUse.sign(proposalHash);
+
+  return new BlockAttestation(payload, attestationSignature, proposerSignature);
 };
 
 export async function randomPublishedL2Block(
@@ -306,16 +336,16 @@ export async function randomPublishedL2Block(
   opts: { signers?: Secp256k1Signer[] } = {},
 ): Promise<PublishedL2Block> {
   const block = await L2Block.random(l2BlockNumber);
-  const l1 = {
+  const l1 = L1PublishedData.fromFields({
     blockNumber: BigInt(block.number),
     timestamp: block.header.globalVariables.timestamp,
     blockHash: Buffer32.random().toString(),
-  };
+  });
 
   const signers = opts.signers ?? times(3, () => Secp256k1Signer.random());
   const atts = await Promise.all(signers.map(signer => makeBlockAttestationFromBlock(block, signer)));
   const attestations = atts.map(
     (attestation, i) => new CommitteeAttestation(signers[i].address, attestation.signature),
   );
-  return { block, l1, attestations };
+  return new PublishedL2Block(block, l1, attestations);
 }

package/src/trees/index.ts

@@ -1,5 +1,4 @@
 export * from './nullifier_leaf.js';
-export * from './protocol_contract_leaf.js';
 export * from './public_data_leaf.js';
 export * from './append_only_tree_snapshot.js';
 export * from './merkle_tree_id.js';

package/src/tx/block_header.ts

@@ -10,9 +10,7 @@ import { inspect } from 'util';
 import { z } from 'zod';
 
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
-import { ContentCommitment } from './content_commitment.js';
 import { GlobalVariables } from './global_variables.js';
-import { ProposedBlockHeader } from './proposed_block_header.js';
 import { StateReference } from './state_reference.js';
 
 /** A header of an L2 block. */
@@ -20,10 +18,13 @@ export class BlockHeader {
   constructor(
     /** Snapshot of archive before the block is applied. */
     public lastArchive: AppendOnlyTreeSnapshot,
-    /** Hash of the body of an L2 block. */
-    public contentCommitment: ContentCommitment,
     /** State reference. */
     public state: StateReference,
+    /**
+     * Hash of the sponge blob after the tx effects of this block has been applied.
+     * May contain tx effects from the previous blocks in the same checkpoint.
+     */
+    public spongeBlobHash: Fr,
     /** Global variables of an L2 block. */
     public globalVariables: GlobalVariables,
     /** Total fees in the block, computed by the root rollup circuit */
@@ -36,8 +37,8 @@ export class BlockHeader {
     return z
       .object({
         lastArchive: AppendOnlyTreeSnapshot.schema,
-        contentCommitment: ContentCommitment.schema,
         state: StateReference.schema,
+        spongeBlobHash: schemas.Fr,
         globalVariables: GlobalVariables.schema,
         totalFees: schemas.Fr,
         totalManaUsed: schemas.Fr,
@@ -46,11 +47,10 @@ export class BlockHeader {
   }
 
   static getFields(fields: FieldsOf<BlockHeader>) {
-    // Note: The order here must match the order in the ProposedHeaderLib solidity library.
     return [
       fields.lastArchive,
-      fields.contentCommitment,
       fields.state,
+      fields.spongeBlobHash,
       fields.globalVariables,
       fields.totalFees,
       fields.totalManaUsed,
@@ -72,8 +72,8 @@ export class BlockHeader {
   getSize() {
     return (
       this.lastArchive.getSize() +
-      this.contentCommitment.getSize() +
       this.state.getSize() +
+      this.spongeBlobHash.size +
       this.globalVariables.getSize() +
       this.totalFees.size +
       this.totalManaUsed.size
@@ -101,8 +101,8 @@ export class BlockHeader {
 
     return new BlockHeader(
       reader.readObject(AppendOnlyTreeSnapshot),
-      reader.readObject(ContentCommitment),
       reader.readObject(StateReference),
+      reader.readObject(Fr),
       reader.readObject(GlobalVariables),
       reader.readObject(Fr),
       reader.readObject(Fr),
@@ -114,8 +114,8 @@ export class BlockHeader {
 
     return new BlockHeader(
       AppendOnlyTreeSnapshot.fromFields(reader),
-      ContentCommitment.fromFields(reader),
       StateReference.fromFields(reader),
+      reader.readField(),
       GlobalVariables.fromFields(reader),
       reader.readField(),
       reader.readField(),
@@ -125,8 +125,8 @@ export class BlockHeader {
   static empty(fields: Partial<FieldsOf<BlockHeader>> = {}): BlockHeader {
     return BlockHeader.from({
       lastArchive: AppendOnlyTreeSnapshot.empty(),
-      contentCommitment: ContentCommitment.empty(),
       state: StateReference.empty(),
+      spongeBlobHash: Fr.ZERO,
       globalVariables: GlobalVariables.empty(),
       totalFees: Fr.ZERO,
       totalManaUsed: Fr.ZERO,
@@ -137,8 +137,8 @@ export class BlockHeader {
   isEmpty(): boolean {
     return (
       this.lastArchive.isEmpty() &&
-      this.contentCommitment.isEmpty() &&
       this.state.isEmpty() &&
+      this.spongeBlobHash.isZero() &&
       this.globalVariables.isEmpty() &&
       this.totalFees.isZero() &&
       this.totalManaUsed.isZero()
@@ -161,24 +161,11 @@ export class BlockHeader {
     return poseidon2HashWithSeparator(this.toFields(), GeneratorIndex.BLOCK_HASH);
   }
 
-  toPropose(): ProposedBlockHeader {
-    return new ProposedBlockHeader(
-      this.lastArchive.root,
-      this.contentCommitment,
-      this.globalVariables.slotNumber,
-      this.globalVariables.timestamp,
-      this.globalVariables.coinbase,
-      this.globalVariables.feeRecipient,
-      this.globalVariables.gasFees,
-      this.totalManaUsed,
-    );
-  }
-
   toInspect() {
     return {
       lastArchive: this.lastArchive.root.toString(),
-      contentCommitment: this.contentCommitment.toInspect(),
       state: this.state.toInspect(),
+      spongeBlobHash: this.spongeBlobHash.toBigInt(),
       globalVariables: this.globalVariables.toInspect(),
       totalFees: this.totalFees.toBigInt(),
       totalManaUsed: this.totalManaUsed.toBigInt(),
@@ -188,13 +175,11 @@ export class BlockHeader {
   [inspect.custom]() {
     return `Header {
   lastArchive: ${inspect(this.lastArchive)},
-  contentCommitment.blobsHash: ${inspect(this.contentCommitment.blobsHash)},
-  contentCommitment.inHash: ${inspect(this.contentCommitment.inHash)},
-  contentCommitment.outHash: ${inspect(this.contentCommitment.outHash)},
   state.l1ToL2MessageTree: ${inspect(this.state.l1ToL2MessageTree)},
   state.noteHashTree: ${inspect(this.state.partial.noteHashTree)},
   state.nullifierTree: ${inspect(this.state.partial.nullifierTree)},
   state.publicDataTree: ${inspect(this.state.partial.publicDataTree)},
+  spongeBlobHash: ${this.spongeBlobHash},
   globalVariables: ${inspect(this.globalVariables)},
   totalFees: ${this.totalFees},
   totalManaUsed: ${this.totalManaUsed},
@@ -203,12 +188,12 @@ export class BlockHeader {
 
   public equals(other: this): boolean {
     return (
-      this.contentCommitment.equals(other.contentCommitment) &&
+      this.lastArchive.equals(other.lastArchive) &&
       this.state.equals(other.state) &&
+      this.spongeBlobHash.equals(other.spongeBlobHash) &&
       this.globalVariables.equals(other.globalVariables) &&
       this.totalFees.equals(other.totalFees) &&
-      this.totalManaUsed.equals(other.totalManaUsed) &&
-      this.lastArchive.equals(other.lastArchive)
+      this.totalManaUsed.equals(other.totalManaUsed)
     );
   }
 }

package/src/tx/content_commitment.ts

@@ -75,6 +75,10 @@ export class ContentCommitment {
     return new ContentCommitment(reader.readField(), reader.readField(), reader.readField());
   }
 
+  static random(): ContentCommitment {
+    return new ContentCommitment(Fr.random(), Fr.random(), Fr.random());
+  }
+
   static empty(): ContentCommitment {
     return new ContentCommitment(Fr.zero(), Fr.zero(), Fr.zero());
   }

package/src/tx/global_variables.ts

@@ -109,7 +109,6 @@ export class GlobalVariables {
   }
 
   static getFields(fields: FieldsOf<GlobalVariables>) {
-    // Note: The order here must match the order in the ProposedHeaderLib solidity library.
     return [
       fields.chainId,
       fields.version,

package/src/tx/index.ts

@@ -6,11 +6,11 @@ export * from './state_reference.js';
 export * from './partial_state_reference.js';
 export * from './function_data.js';
 export * from './tree_snapshots.js';
+export * from './private_tx_constant_data.js';
 export * from './tx_constant_data.js';
 export * from './tx_context.js';
 export * from './tx_request.js';
 export * from './private_execution_result.js';
-export * from './proposed_block_header.js';
 export * from './public_call_request_with_calldata.js';
 export * from './tx_hash.js';
 export * from './tx_receipt.js';
@@ -30,3 +30,4 @@ export * from './hashed_values.js';
 export * from './indexed_tx_effect.js';
 export * from './offchain_effect.js';
 export * from './profiling.js';
+export * from './protocol_contracts.js';

package/src/tx/partial_state_reference.ts

@@ -64,6 +64,14 @@ export class PartialStateReference {
     );
   }
 
+  static random(): PartialStateReference {
+    return new PartialStateReference(
+      AppendOnlyTreeSnapshot.random(),
+      AppendOnlyTreeSnapshot.random(),
+      AppendOnlyTreeSnapshot.random(),
+    );
+  }
+
   toViem(): ViemPartialStateReference {
     return {
       noteHashTree: this.noteHashTree.toViem(),

package/src/tx/private_execution_result.ts

@@ -10,6 +10,7 @@ import { PrivateCircuitPublicInputs } from '../kernel/private_circuit_public_inp
 import type { IsEmpty } from '../kernel/utils/interfaces.js';
 import { sortByCounter } from '../kernel/utils/order_and_comparison.js';
 import { ContractClassLog, ContractClassLogFields } from '../logs/contract_class_log.js';
+import { type PreTag, PreTagSchema } from '../logs/pre_tag.js';
 import { Note } from '../note/note.js';
 import { type ZodFor, mapSchema, schemas } from '../schemas/index.js';
 import type { UInt32 } from '../types/index.js';
@@ -103,10 +104,10 @@ export class PrivateExecutionResult {
   }
 
   /**
-   * The block number that this execution was simulated with.
+   * The anchor block number that this execution was simulated with.
    */
-  getSimulationBlockNumber(): UInt32 {
-    return this.entrypoint.publicInputs.historicalHeader.globalVariables.blockNumber;
+  getSimulationAnchorBlockNumber(): UInt32 {
+    return this.entrypoint.publicInputs.anchorBlockHeader.globalVariables.blockNumber;
   }
 }
 
@@ -135,6 +136,8 @@ export class PrivateCallExecutionResult {
     public returnValues: Fr[],
     /** The offchain effects emitted during execution of this function call via the `emit_offchain_effect` oracle. */
     public offchainEffects: { data: Fr[] }[],
+    /** The pre tags used in this tx to compute tags for private logs */
+    public preTags: PreTag[],
     /** The nested executions. */
     public nestedExecutionResults: PrivateCallExecutionResult[],
     /**
@@ -158,6 +161,7 @@ export class PrivateCallExecutionResult {
         noteHashNullifierCounterMap: mapSchema(z.coerce.number(), z.number()),
         returnValues: z.array(schemas.Fr),
         offchainEffects: z.array(z.object({ data: z.array(schemas.Fr) })),
+        preTags: z.array(PreTagSchema),
         nestedExecutionResults: z.array(z.lazy(() => PrivateCallExecutionResult.schema)),
         contractClassLogs: z.array(CountedContractClassLog.schema),
       })
@@ -175,6 +179,7 @@ export class PrivateCallExecutionResult {
       fields.noteHashNullifierCounterMap,
       fields.returnValues,
       fields.offchainEffects,
+      fields.preTags,
       fields.nestedExecutionResults,
       fields.contractClassLogs,
     );
@@ -195,6 +200,7 @@ export class PrivateCallExecutionResult {
           data: [Fr.random()],
         },
       ],
+      [],
       await timesParallel(nested, () => PrivateCallExecutionResult.random(0)),
       [new CountedContractClassLog(await ContractClassLog.random(), randomInt(10))],
     );

package/src/tx/private_tx_constant_data.ts

@@ -0,0 +1,94 @@
+import { TX_CONSTANT_DATA_LENGTH } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+
+import { BlockHeader } from './block_header.js';
+import { ProtocolContracts } from './protocol_contracts.js';
+import { TxContext } from './tx_context.js';
+
+/**
+ * Data that is constant/not modified by neither of the kernels.
+ */
+export class PrivateTxConstantData {
+  constructor(
+    /** Header of a block whose state is used during execution (not the block the transaction is included in). */
+    public anchorBlockHeader: BlockHeader,
+    /**
+     * Context of the transaction.
+     *
+     * Note: `chainId` and `version` in txContext are not redundant to the values in
+     * self.anchor_block_header.global_variables because they can be different in case of a protocol upgrade. In such
+     * a situation we could be using header from a block before the upgrade took place but be using the updated
+     * protocol to execute and prove the transaction.
+     */
+    public txContext: TxContext,
+    /**
+     * Root of the vk tree for the protocol circuits.
+     */
+    public vkTreeRoot: Fr,
+    /**
+     * List of protocol contracts.
+     */
+    public protocolContracts: ProtocolContracts,
+  ) {}
+
+  static from(fields: FieldsOf<PrivateTxConstantData>) {
+    return new PrivateTxConstantData(...PrivateTxConstantData.getFields(fields));
+  }
+
+  static getFields(fields: FieldsOf<PrivateTxConstantData>) {
+    return [fields.anchorBlockHeader, fields.txContext, fields.vkTreeRoot, fields.protocolContracts] as const;
+  }
+
+  static fromFields(fields: Fr[] | FieldReader): PrivateTxConstantData {
+    const reader = FieldReader.asReader(fields);
+    return new PrivateTxConstantData(
+      reader.readObject(BlockHeader),
+      reader.readObject(TxContext),
+      reader.readField(),
+      reader.readObject(ProtocolContracts),
+    );
+  }
+
+  toFields(): Fr[] {
+    const fields = serializeToFields(...PrivateTxConstantData.getFields(this));
+    if (fields.length !== TX_CONSTANT_DATA_LENGTH) {
+      throw new Error(
+        `Invalid number of fields for PrivateTxConstantData. Expected ${TX_CONSTANT_DATA_LENGTH}, got ${fields.length}`,
+      );
+    }
+    return fields;
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader): PrivateTxConstantData {
+    const reader = BufferReader.asReader(buffer);
+    return new PrivateTxConstantData(
+      reader.readObject(BlockHeader),
+      reader.readObject(TxContext),
+      Fr.fromBuffer(reader),
+      reader.readObject(ProtocolContracts),
+    );
+  }
+
+  toBuffer() {
+    return serializeToBuffer(...PrivateTxConstantData.getFields(this));
+  }
+
+  static empty() {
+    return new PrivateTxConstantData(BlockHeader.empty(), TxContext.empty(), Fr.ZERO, ProtocolContracts.empty());
+  }
+
+  getSize() {
+    return (
+      this.anchorBlockHeader.getSize() +
+      this.txContext.getSize() +
+      this.vkTreeRoot.size +
+      this.protocolContracts.getSize()
+    );
+  }
+
+  clone(): PrivateTxConstantData {
+    return PrivateTxConstantData.fromBuffer(this.toBuffer());
+  }
+}