@aztec/stdlib 3.0.0-nightly.20250924 → 3.0.0-nightly.20250926

package/dest/tests/factories.js

@@ -1,6 +1,6 @@
 import { BlobAccumulatorPublicInputs, FinalBlobAccumulatorPublicInputs } from '@aztec/blob-lib';
 import { makeBatchedBlobAccumulator, makeSpongeBlob } from '@aztec/blob-lib/testing';
-import { ARCHIVE_HEIGHT, AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, AZTEC_MAX_EPOCH_DURATION, CIVC_PROOF_LENGTH, CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, FIXED_DA_GAS, FIXED_L2_GAS, GeneratorIndex, L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH, MAX_CONTRACT_CLASS_LOGS_PER_TX, MAX_ENQUEUED_CALLS_PER_CALL, MAX_ENQUEUED_CALLS_PER_TX, MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_TX, MAX_NOTE_HASHES_PER_CALL, MAX_NOTE_HASHES_PER_TX, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL, MAX_NULLIFIERS_PER_TX, MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL, MAX_PRIVATE_LOGS_PER_TX, MAX_PROTOCOL_CONTRACTS, MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH, NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH, NULLIFIER_TREE_HEIGHT, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, NUM_BASE_PARITY_PER_ROOT_PARITY, NUM_MSGS_PER_BASE_PARITY, PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DATA_TREE_HEIGHT, RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, VK_TREE_HEIGHT } from '@aztec/constants';
+import { ARCHIVE_HEIGHT, AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, AZTEC_MAX_EPOCH_DURATION, CIVC_PROOF_LENGTH, CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, FIXED_DA_GAS, FIXED_L2_GAS, GeneratorIndex, L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, MAX_CONTRACT_CLASS_LOGS_PER_TX, MAX_ENQUEUED_CALLS_PER_CALL, MAX_ENQUEUED_CALLS_PER_TX, MAX_KEY_VALIDATION_REQUESTS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_TX, MAX_NOTE_HASHES_PER_CALL, MAX_NOTE_HASHES_PER_TX, MAX_NOTE_HASH_READ_REQUESTS_PER_CALL, MAX_NULLIFIERS_PER_CALL, MAX_NULLIFIERS_PER_TX, MAX_NULLIFIER_READ_REQUESTS_PER_CALL, MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, MAX_PRIVATE_LOGS_PER_CALL, MAX_PRIVATE_LOGS_PER_TX, MAX_PROTOCOL_CONTRACTS, MAX_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, NOTE_HASH_SUBTREE_ROOT_SIBLING_PATH_LENGTH, NULLIFIER_SUBTREE_ROOT_SIBLING_PATH_LENGTH, NULLIFIER_TREE_HEIGHT, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, NUM_BASE_PARITY_PER_ROOT_PARITY, NUM_MSGS_PER_BASE_PARITY, PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DATA_TREE_HEIGHT, RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, VK_TREE_HEIGHT } from '@aztec/constants';
 import { makeHalfFullTuple, makeTuple } from '@aztec/foundation/array';
 import { compact, padArrayEnd } from '@aztec/foundation/collection';
 import { SchnorrSignature, poseidon2HashWithSeparator, sha256 } from '@aztec/foundation/crypto';
@@ -11,7 +11,6 @@ import { FunctionSelector } from '../abi/function_selector.js';
 import { ContractStorageRead } from '../avm/contract_storage_read.js';
 import { ContractStorageUpdateRequest } from '../avm/contract_storage_update_request.js';
 import { AvmAccumulatedData, AvmAccumulatedDataArrayLengths, AvmAppendLeavesHint, AvmBytecodeCommitmentHint, AvmCircuitInputs, AvmCircuitPublicInputs, AvmCommitCheckpointHint, AvmContractClassHint, AvmContractInstanceHint, AvmCreateCheckpointHint, AvmExecutionHints, AvmGetLeafPreimageHintNullifierTree, AvmGetLeafPreimageHintPublicDataTree, AvmGetLeafValueHint, AvmGetPreviousValueIndexHint, AvmGetSiblingPathHint, AvmProtocolContractAddressHint, AvmRevertCheckpointHint, AvmSequentialInsertHintNullifierTree, AvmSequentialInsertHintPublicDataTree, AvmTxHint, RevertCode } from '../avm/index.js';
-import { PublicDataHint } from '../avm/public_data_hint.js';
 import { PublicDataRead } from '../avm/public_data_read.js';
 import { PublicDataWrite } from '../avm/public_data_write.js';
 import { AztecAddress } from '../aztec-address/index.js';
@@ -43,7 +42,6 @@ import { ProofData } from '../proofs/index.js';
 import { Proof } from '../proofs/proof.js';
 import { ProvingRequestType } from '../proofs/proving_request_type.js';
 import { makeRecursiveProof } from '../proofs/recursive_proof.js';
-import { AvmProofData } from '../rollup/avm_proof_data.js';
 import { PrivateBaseRollupHints, PublicBaseRollupHints } from '../rollup/base_rollup_hints.js';
 import { BlockConstantData } from '../rollup/block_constant_data.js';
 import { BlockMergeRollupPrivateInputs } from '../rollup/block_merge_rollup_private_inputs.js';
@@ -56,7 +54,7 @@ import { EpochConstantData } from '../rollup/epoch_constant_data.js';
 import { PrivateTxBaseRollupPrivateInputs } from '../rollup/private_tx_base_rollup_private_inputs.js';
 import { PublicTxBaseRollupPrivateInputs } from '../rollup/public_tx_base_rollup_private_inputs.js';
 import { RootRollupPublicInputs } from '../rollup/root_rollup_public_inputs.js';
-import { PrivateBaseStateDiffHints } from '../rollup/state_diff_hints.js';
+import { TreeSnapshotDiffHints } from '../rollup/tree_snapshot_diff_hints.js';
 import { TxMergeRollupPrivateInputs } from '../rollup/tx_merge_rollup_private_inputs.js';
 import { TxRollupPublicInputs } from '../rollup/tx_rollup_public_inputs.js';
 import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js';
@@ -534,7 +532,7 @@ export function makeBlockRootFirstRollupPrivateInputs(seed = 0) {
     return new BlockRootFirstRollupPrivateInputs(makeProofData(seed, makeParityPublicInputs), [
         makeProofData(seed + 0x1000, makeTxRollupPublicInputs),
         makeProofData(seed + 0x2000, makeTxRollupPublicInputs)
-    ], makeAppendOnlyTreeSnapshot(seed + 0x3000), makeSiblingPath(seed + 0x4000, L1_TO_L2_MSG_SUBTREE_SIBLING_PATH_LENGTH), makeSiblingPath(seed + 0x5000, ARCHIVE_HEIGHT));
+    ], makeAppendOnlyTreeSnapshot(seed + 0x3000), makeSiblingPath(seed + 0x4000, L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH), makeSiblingPath(seed + 0x5000, ARCHIVE_HEIGHT));
 }
 export function makeBlockRootSingleTxRollupPrivateInputs(seed = 0) {
     return new BlockRootSingleTxRollupPrivateInputs(makeProofData(seed + 0x1000, makeTxRollupPublicInputs), makeSiblingPath(seed + 0x4000, ARCHIVE_HEIGHT));
@@ -578,20 +576,18 @@ export function makeBlockRootSingleTxRollupPrivateInputs(seed = 0) {
     return new PublicDataTreeLeafPreimage(makePublicDataTreeLeaf(seed), new Fr(seed + 2), BigInt(seed + 3));
 }
 /**
- * Creates an instance of PrivateBaseStateDiffHints with arbitrary values based on the provided seed.
+ * Creates an instance of TreeSnapshotDiffHints with arbitrary values based on the provided seed.
  * @param seed - The seed to use for generating the hints.
- * @returns A PrivateBaseStateDiffHints object.
- */ export function makePrivateBaseStateDiffHints(seed = 1) {
+ * @returns A TreeSnapshotDiffHints object.
+ */ export function makeTreeSnapshotDiffHints(seed = 1) {
     const nullifierPredecessorPreimages = makeTuple(MAX_NULLIFIERS_PER_TX, (x)=>makeNullifierLeafPreimage(x), seed + 0x1000);
     const nullifierPredecessorMembershipWitnesses = makeTuple(MAX_NULLIFIERS_PER_TX, (x)=>makeMembershipWitness(NULLIFIER_TREE_HEIGHT, x), seed + 0x2000);
     const sortedNullifiers = makeTuple(MAX_NULLIFIERS_PER_TX, fr, seed + 0x3000);
     const sortedNullifierIndexes = makeTuple(MAX_NULLIFIERS_PER_TX, (i)=>i, seed + 0x4000);
-    const noteHashSubtreeSiblingPath = makeTuple(NOTE_HASH_SUBTREE_SIBLING_PATH_LENGTH, fr, seed + 0x5000);
-    const nullifierSubtreeSiblingPath = makeTuple(NULLIFIER_SUBTREE_SIBLING_PATH_LENGTH, fr, seed + 0x6000);
-    const feeWriteLowLeafPreimage = makePublicDataTreeLeafPreimage(seed + 0x7000);
-    const feeWriteLowLeafMembershipWitness = makeMembershipWitness(PUBLIC_DATA_TREE_HEIGHT, seed + 0x8000);
-    const feeWriteSiblingPath = makeTuple(PUBLIC_DATA_TREE_HEIGHT, fr, seed + 0x9000);
-    return new PrivateBaseStateDiffHints(nullifierPredecessorPreimages, nullifierPredecessorMembershipWitnesses, sortedNullifiers, sortedNullifierIndexes, noteHashSubtreeSiblingPath, nullifierSubtreeSiblingPath, feeWriteLowLeafPreimage, feeWriteLowLeafMembershipWitness, feeWriteSiblingPath);
+    const noteHashSubtreeRootSiblingPath = makeTuple(NOTE_HASH_SUBTREE_ROOT_SIBLING_PATH_LENGTH, fr, seed + 0x5000);
+    const nullifierSubtreeRootSiblingPath = makeTuple(NULLIFIER_SUBTREE_ROOT_SIBLING_PATH_LENGTH, fr, seed + 0x6000);
+    const feePayerBalanceMembershipWitness = makeMembershipWitness(PUBLIC_DATA_TREE_HEIGHT, seed + 0x8000);
+    return new TreeSnapshotDiffHints(noteHashSubtreeRootSiblingPath, nullifierPredecessorPreimages, nullifierPredecessorMembershipWitnesses, sortedNullifiers, sortedNullifierIndexes, nullifierSubtreeRootSiblingPath, feePayerBalanceMembershipWitness);
 }
 function makeVkData(seed = 1) {
     return new VkData(VerificationKeyData.makeFakeHonk(), seed, makeTuple(VK_TREE_HEIGHT, fr, seed + 0x100));
@@ -605,17 +601,17 @@ function makeContractClassLogFields(seed = 1) {
 function makePrivateBaseRollupHints(seed = 1) {
     const start = makePartialStateReference(seed + 0x100);
     const startSpongeBlob = makeSpongeBlob(seed + 0x200);
-    const stateDiffHints = makePrivateBaseStateDiffHints(seed + 0x600);
-    const archiveRootMembershipWitness = makeMembershipWitness(ARCHIVE_HEIGHT, seed + 0x9000);
+    const treeSnapshotDiffHints = makeTreeSnapshotDiffHints(seed + 0x600);
+    const anchorBlockArchiveSiblingPath = makeSiblingPath(seed + 0x9000, ARCHIVE_HEIGHT);
     const contractClassLogsFields = makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, makeContractClassLogFields, seed + 0x800);
     const constants = makeBlockConstantData(0x100);
-    const feePayerFeeJuiceBalanceReadHint = PublicDataHint.empty();
+    const feePayerBalanceLeafPreimage = PublicDataTreeLeafPreimage.empty();
     return PrivateBaseRollupHints.from({
         start,
         startSpongeBlob,
-        stateDiffHints,
-        feePayerFeeJuiceBalanceReadHint,
-        archiveRootMembershipWitness,
+        treeSnapshotDiffHints,
+        feePayerBalanceLeafPreimage,
+        anchorBlockArchiveSiblingPath,
         contractClassLogsFields,
         constants
     });
@@ -624,7 +620,7 @@ function makePublicBaseRollupHints(seed = 1) {
     return PublicBaseRollupHints.from({
         startSpongeBlob: makeSpongeBlob(seed),
         lastArchive: makeAppendOnlyTreeSnapshot(seed + 0x1000),
-        archiveRootMembershipWitness: makeMembershipWitness(ARCHIVE_HEIGHT, seed + 0x2000),
+        anchorBlockArchiveSiblingPath: makeSiblingPath(seed + 0x2000, ARCHIVE_HEIGHT),
         contractClassLogsFields: makeTuple(MAX_CONTRACT_CLASS_LOGS_PER_TX, makeContractClassLogFields, seed + 0x3000),
         proverId: fr(seed + 0x4000)
     });
@@ -635,12 +631,9 @@ export function makePrivateTxBaseRollupPrivateInputs(seed = 0) {
         hints: makePrivateBaseRollupHints(seed + 0x100)
     });
 }
-function makeAvmProofData(seed = 1) {
-    return new AvmProofData(makeAvmCircuitPublicInputs(seed), makeRecursiveProof(AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED, seed + 0x100), makeVkData(seed + 0x200));
-}
 export function makePublicTxBaseRollupPrivateInputs(seed = 0) {
     const publicTubeProofData = makeProofData(seed, makePrivateToPublicKernelCircuitPublicInputs, RECURSIVE_ROLLUP_HONK_PROOF_LENGTH);
-    const avmProofData = makeAvmProofData(seed + 0x100);
+    const avmProofData = makeProofData(seed + 0x100, makeAvmCircuitPublicInputs, AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED);
     const hints = makePublicBaseRollupHints(seed + 0x200);
     return PublicTxBaseRollupPrivateInputs.from({
         publicTubeProofData,
@@ -948,6 +941,7 @@ export function makeAvmProtocolContractDerivedAddressesHint(seed = 0) {
         // Create avm output.
         const avmOutput = AvmCircuitPublicInputs.empty();
         // Assign data from hints.
+        avmOutput.protocolContractTreeRoot = protocolContractTreeRoot;
         avmOutput.startTreeSnapshots.l1ToL2MessageTree = newL1ToL2Snapshot;
         avmOutput.endTreeSnapshots.l1ToL2MessageTree = newL1ToL2Snapshot;
         // Assign data from private.
@@ -968,6 +962,7 @@ export function makeAvmProtocolContractDerivedAddressesHint(seed = 0) {
         avmOutput.accumulatedData.nullifiers = padArrayEnd(nonRevertibleData.nullifiers.concat(revertibleData.nullifiers).filter((n)=>!n.isEmpty()), Fr.ZERO, MAX_NULLIFIERS_PER_TX);
         avmOutput.accumulatedData.l2ToL1Msgs = revertibleData.l2ToL1Msgs;
         avmOutput.accumulatedData.publicDataWrites = makeTuple(MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX, (i)=>new PublicDataWrite(new Fr(i), new Fr(i + 10)), seed + 0x2000);
+        avmOutput.accumulatedDataArrayLengths = avmOutput.accumulatedData.getArrayLengths();
         avmOutput.gasSettings = gasSettings;
         const avmCircuitInputs = await makeAvmCircuitInputs(seed + 0x3000, {
             publicInputs: avmOutput

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/stdlib",
-  "version": "3.0.0-nightly.20250924",
+  "version": "3.0.0-nightly.20250926",
   "type": "module",
   "inherits": [
     "../package.common.json",
@@ -69,13 +69,14 @@
     "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
   },
   "dependencies": {
-    "@aztec/bb.js": "3.0.0-nightly.20250924",
-    "@aztec/blob-lib": "3.0.0-nightly.20250924",
-    "@aztec/constants": "3.0.0-nightly.20250924",
-    "@aztec/ethereum": "3.0.0-nightly.20250924",
-    "@aztec/foundation": "3.0.0-nightly.20250924",
-    "@aztec/l1-artifacts": "3.0.0-nightly.20250924",
-    "@aztec/noir-noirc_abi": "3.0.0-nightly.20250924",
+    "@aws-sdk/client-s3": "^3.892.0",
+    "@aztec/bb.js": "3.0.0-nightly.20250926",
+    "@aztec/blob-lib": "3.0.0-nightly.20250926",
+    "@aztec/constants": "3.0.0-nightly.20250926",
+    "@aztec/ethereum": "3.0.0-nightly.20250926",
+    "@aztec/foundation": "3.0.0-nightly.20250926",
+    "@aztec/l1-artifacts": "3.0.0-nightly.20250926",
+    "@aztec/noir-noirc_abi": "3.0.0-nightly.20250926",
     "@google-cloud/storage": "^7.15.0",
     "axios": "^1.9.0",
     "json-stringify-deterministic": "1.0.12",

package/src/avm/avm_accumulated_data.ts

@@ -22,6 +22,7 @@ import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 import { inspect } from 'util';
 import { z } from 'zod';
 
+import { countAccumulatedItems } from '../kernel/utils/index.js';
 import { FlatPublicLogs } from '../logs/public_log.js';
 import { ScopedL2ToL1Message } from '../messaging/l2_to_l1_message.js';
 import { PublicDataWrite } from './public_data_write.js';
@@ -184,6 +185,15 @@ export class AvmAccumulatedData {
     .join(', ')}],
 }`;
   }
+
+  getArrayLengths() {
+    return new AvmAccumulatedDataArrayLengths(
+      countAccumulatedItems(this.noteHashes),
+      countAccumulatedItems(this.nullifiers),
+      countAccumulatedItems(this.l2ToL1Msgs),
+      countAccumulatedItems(this.publicDataWrites),
+    );
+  }
 }
 
 /**

package/src/avm/index.ts

@@ -3,7 +3,6 @@ export * from './avm_accumulated_data.js';
 export * from './avm_circuit_public_inputs.js';
 export * from './revert_code.js';
 export * from './public_data_write.js';
-export * from './public_data_hint.js';
 export * from './public_data_update_request.js';
 export * from './contract_storage_update_request.js';
 export * from './contract_storage_read.js';

package/src/file-store/factory.ts

@@ -4,9 +4,11 @@ import { GoogleCloudFileStore } from './gcs.js';
 import { HttpFileStore } from './http.js';
 import type { FileStore, ReadOnlyFileStore } from './interface.js';
 import { LocalFileStore } from './local.js';
+import { S3FileStore } from './s3.js';
 
 const supportedExamples = [
   `gs://bucket-name/path/to/store`,
+  `s3://bucket-name/path/to/store`,
   `file:///absolute/local/path/to/store`,
   `https://host/path`,
 ];
@@ -39,6 +41,19 @@ export async function createFileStore(
     } catch {
       throw new Error(`Invalid google cloud store definition: '${config}'.`);
     }
+  } else if (config.startsWith('s3://')) {
+    try {
+      const url = new URL(config);
+      const bucket = url.host;
+      const path = url.pathname.replace(/^\/+/, '');
+      const endpoint = url.searchParams.get('endpoint');
+      const publicBaseUrl = url.searchParams.get('publicBaseUrl') ?? undefined;
+      logger.info(`Creating S3 file store at ${bucket} ${path}`);
+      const store = new S3FileStore(bucket, path, { endpoint: endpoint ?? undefined, publicBaseUrl });
+      return store;
+    } catch {
+      throw new Error(`Invalid S3 store definition: '${config}'.`);
+    }
   } else {
     throw new Error(`Unknown file store config: '${config}'. Supported values are ${supportedExamples.join(', ')}.`);
   }

package/src/file-store/s3.ts

@@ -0,0 +1,186 @@
+import { type Logger, createLogger } from '@aztec/foundation/log';
+
+import {
+  GetObjectCommand,
+  type GetObjectCommandOutput,
+  HeadObjectCommand,
+  PutObjectCommand,
+  S3Client,
+} from '@aws-sdk/client-s3';
+import { createReadStream, createWriteStream } from 'fs';
+import { mkdir } from 'fs/promises';
+import { dirname, join } from 'path';
+import { Readable } from 'stream';
+import { finished } from 'stream/promises';
+import { createGzip } from 'zlib';
+
+import type { FileStore, FileStoreSaveOptions } from './interface.js';
+
+function normalizeBasePath(path: string): string {
+  return path?.replace(/^\/+|\/+$/g, '') ?? '';
+}
+
+export class S3FileStore implements FileStore {
+  private readonly s3: S3Client;
+  private readonly region: string;
+  private readonly endpoint?: string;
+  private readonly publicBaseUrl?: string;
+
+  constructor(
+    private readonly bucketName: string,
+    private readonly basePath: string,
+    opts: { endpoint?: string; publicBaseUrl?: string },
+    private readonly log: Logger = createLogger('stdlib:s3-file-store'),
+  ) {
+    this.endpoint = opts.endpoint;
+    this.region = this.endpoint ? 'auto' : (process.env.AWS_REGION ?? process.env.AWS_DEFAULT_REGION ?? 'us-east-1');
+    this.publicBaseUrl = opts.publicBaseUrl;
+
+    const clientOptions: any = {};
+    if (this.endpoint) {
+      clientOptions.region = 'auto';
+      clientOptions.endpoint = this.endpoint;
+      clientOptions.forcePathStyle = true;
+    } else {
+      clientOptions.region = this.region;
+    }
+    this.s3 = new S3Client(clientOptions);
+  }
+
+  public async save(path: string, data: Buffer, opts: FileStoreSaveOptions = {}): Promise<string> {
+    const key = this.getFullPath(path);
+    const shouldCompress = !opts.compress;
+    const body = shouldCompress ? (await import('zlib')).gzipSync(data) : data;
+    const put = new PutObjectCommand({
+      Bucket: this.bucketName,
+      Key: key,
+      Body: body,
+      ContentEncoding: shouldCompress ? 'gzip' : undefined,
+      CacheControl: opts.metadata?.['Cache-control'],
+      Metadata: this.extractUserMetadata(opts.metadata),
+    });
+    await this.s3.send(put);
+    return this.buildReturnedUrl(key, !!opts.public);
+  }
+
+  public async upload(destPath: string, srcPath: string, opts: FileStoreSaveOptions = {}): Promise<string> {
+    const key = this.getFullPath(destPath);
+    const shouldCompress = opts.compress !== false; // default true like GCS impl
+
+    await mkdir(dirname(srcPath), { recursive: true }).catch(() => undefined);
+
+    const source = createReadStream(srcPath);
+    const bodyStream = shouldCompress ? source.pipe(createGzip()) : source;
+    const put = new PutObjectCommand({
+      Bucket: this.bucketName,
+      Key: key,
+      Body: bodyStream as any,
+      ContentEncoding: shouldCompress ? 'gzip' : undefined,
+      CacheControl: opts.metadata?.['Cache-control'],
+      Metadata: this.extractUserMetadata(opts.metadata),
+    });
+    await this.s3.send(put);
+    return this.buildReturnedUrl(key, !!opts.public);
+  }
+
+  public async read(pathOrUrlStr: string): Promise<Buffer> {
+    const { bucket, key } = this.getBucketAndKey(pathOrUrlStr);
+    const out: GetObjectCommandOutput = await this.s3.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
+    const stream = out.Body as Readable;
+    const chunks: Buffer[] = [];
+    for await (const chunk of stream) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks);
+  }
+
+  public async download(pathOrUrlStr: string, destPath: string): Promise<void> {
+    const { bucket, key } = this.getBucketAndKey(pathOrUrlStr);
+    const out: GetObjectCommandOutput = await this.s3.send(new GetObjectCommand({ Bucket: bucket, Key: key }));
+    await mkdir(dirname(destPath), { recursive: true });
+    const write = createWriteStream(destPath);
+    await finished((out.Body as Readable).pipe(write));
+  }
+
+  public async exists(pathOrUrlStr: string): Promise<boolean> {
+    try {
+      const { bucket, key } = this.getBucketAndKey(pathOrUrlStr);
+      await this.s3.send(new HeadObjectCommand({ Bucket: bucket, Key: key }));
+      return true;
+    } catch (err: any) {
+      const code = err?.$metadata?.httpStatusCode ?? err?.name ?? err?.Code;
+      if (code === 404 || code === 'NotFound' || code === 'NoSuchKey') {
+        return false;
+      }
+      this.log.warn(`Error checking existence for ${pathOrUrlStr}: ${err?.message ?? String(err)}`);
+      return false;
+    }
+  }
+
+  private extractUserMetadata(meta?: Record<string, string>): Record<string, string> | undefined {
+    if (!meta) {
+      return undefined;
+    }
+    const { ['Cache-control']: _ignored, ...rest } = meta;
+    return Object.keys(rest).length ? rest : undefined;
+  }
+
+  private buildReturnedUrl(key: string, makePublic: boolean): string {
+    if (!makePublic) {
+      return `s3://${this.bucketName}/${key}`;
+    }
+
+    if (this.publicBaseUrl) {
+      const base = this.publicBaseUrl.replace(/\/$/, '');
+      // key already includes basePath via getFullPath, so do not prefix basePath again
+      const full = key.replace(/^\/+/, '');
+      return `${base}/${full}`;
+    }
+
+    // Try to synthesize a URL from endpoint if available (works for public R2 buckets)
+    if (this.endpoint) {
+      try {
+        const url = new URL(this.endpoint);
+        return `https://${this.bucketName}.${url.host}/${key}`;
+      } catch {
+        // fallthrough
+      }
+    }
+
+    // Fallback to AWS style URL if region looks valid
+    return `https://${this.bucketName}.s3.${this.region}.amazonaws.com/${key}`;
+  }
+
+  private getBucketAndKey(pathOrUrlStr: string): { bucket: string; key: string } {
+    if (URL.canParse(pathOrUrlStr)) {
+      const url = new URL(pathOrUrlStr);
+      if (url.protocol === 's3:') {
+        return { bucket: url.host, key: url.pathname.replace(/^\/+/, '') };
+      }
+      // For https URLs, try to infer virtual-hosted or path-style
+      if (url.protocol === 'https:' || url.protocol === 'http:') {
+        // If the URL matches the configured publicBaseUrl host, map back to our bucket and key
+        if (this.publicBaseUrl && url.host === new URL(this.publicBaseUrl).host) {
+          return { bucket: this.bucketName, key: url.pathname.replace(/^\/+/, '') };
+        }
+        const hostParts = url.host.split('.');
+        if (hostParts.length > 3 && (hostParts[1] === 's3' || hostParts[hostParts.length - 2] === 'r2')) {
+          // virtual hosted
+          return { bucket: hostParts[0], key: url.pathname.replace(/^\/+/, '') };
+        } else if (this.endpoint && url.host === new URL(this.endpoint).host) {
+          // path-style at custom endpoint
+          const [bucket, ...rest] = url.pathname.replace(/^\/+/, '').split('/');
+          return { bucket, key: rest.join('/') };
+        }
+      }
+    }
+    // Treat as path
+    return { bucket: this.bucketName, key: this.getFullPath(pathOrUrlStr) };
+  }
+
+  private getFullPath(path: string): string {
+    const base = normalizeBasePath(this.basePath);
+    const rel = path.replace(/^\/+/, '');
+    return base ? join(base, rel) : rel;
+  }
+}

package/src/interfaces/pxe.ts

@@ -1,25 +1,21 @@
 import type { Fr } from '@aztec/foundation/fields';
-import type { ApiSchemaFor, ZodFor } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
 
-import { type AbiType, AbiTypeSchema, type ContractArtifact, ContractArtifactSchema } from '../abi/abi.js';
+import { type AbiType, AbiTypeSchema, type ContractArtifact } from '../abi/abi.js';
 import type { EventSelector } from '../abi/event_selector.js';
 import { AuthWitness } from '../auth_witness/auth_witness.js';
 import type { AztecAddress } from '../aztec-address/index.js';
 import {
   CompleteAddress,
   type ContractClassWithId,
-  ContractClassWithIdSchema,
   type ContractInstanceWithAddress,
-  ContractInstanceWithAddressSchema,
   type PartialAddress,
   type ProtocolContractAddresses,
-  ProtocolContractAddressesSchema,
 } from '../contract/index.js';
 import { UniqueNote } from '../note/extended_note.js';
-import { type NotesFilter, NotesFilterSchema } from '../note/notes_filter.js';
-import { AbiDecodedSchema, optional, schemas } from '../schemas/schemas.js';
+import type { NotesFilter } from '../note/notes_filter.js';
+import { schemas } from '../schemas/schemas.js';
 import { SimulationOverrides, TxExecutionRequest, TxSimulationResult } from '../tx/index.js';
 import { TxProfileResult, UtilitySimulationResult } from '../tx/profiling.js';
 import { TxProvingResult } from '../tx/proven_tx.js';
@@ -241,6 +237,11 @@ export interface PXE {
     numBlocks: number,
     recipients: AztecAddress[],
   ): Promise<T[]>;
+
+  /**
+   * Stops the PXE's job queue.
+   */
+  stop(): Promise<void>;
 }
 // docs:end:pxe-interface
 
@@ -281,76 +282,3 @@ export interface ContractClassMetadata {
   isContractClassPubliclyRegistered: boolean;
   artifact?: ContractArtifact | undefined;
 }
-
-export const ContractMetadataSchema = z.object({
-  contractInstance: z.union([ContractInstanceWithAddressSchema, z.undefined()]),
-  isContractInitialized: z.boolean(),
-  isContractPublished: z.boolean(),
-}) satisfies ZodFor<ContractMetadata>;
-
-export const ContractClassMetadataSchema = z.object({
-  contractClass: z.union([ContractClassWithIdSchema, z.undefined()]),
-  isContractClassPubliclyRegistered: z.boolean(),
-  artifact: z.union([ContractArtifactSchema, z.undefined()]),
-}) satisfies ZodFor<ContractClassMetadata>;
-
-const PXEInfoSchema = z.object({
-  pxeVersion: z.string(),
-  protocolContractAddresses: ProtocolContractAddressesSchema,
-}) satisfies ZodFor<PXEInfo>;
-
-export const PXESchema: ApiSchemaFor<PXE> = {
-  registerAccount: z.function().args(schemas.Fr, schemas.Fr).returns(CompleteAddress.schema),
-  getRegisteredAccounts: z.function().returns(z.array(CompleteAddress.schema)),
-  registerSender: z.function().args(schemas.AztecAddress).returns(schemas.AztecAddress),
-  getSenders: z.function().returns(z.array(schemas.AztecAddress)),
-  removeSender: z.function().args(schemas.AztecAddress).returns(z.void()),
-  registerContractClass: z.function().args(ContractArtifactSchema).returns(z.void()),
-  registerContract: z
-    .function()
-    .args(z.object({ instance: ContractInstanceWithAddressSchema, artifact: z.optional(ContractArtifactSchema) }))
-    .returns(z.void()),
-  updateContract: z.function().args(schemas.AztecAddress, ContractArtifactSchema).returns(z.void()),
-  getContracts: z.function().returns(z.array(schemas.AztecAddress)),
-  proveTx: z.function().args(TxExecutionRequest.schema).returns(TxProvingResult.schema),
-  profileTx: z
-    .function()
-    .args(
-      TxExecutionRequest.schema,
-      z.union([z.literal('gates'), z.literal('full'), z.literal('execution-steps')]),
-      optional(z.boolean()),
-      optional(schemas.AztecAddress),
-    )
-    .returns(TxProfileResult.schema),
-  simulateTx: z
-    .function()
-    .args(
-      TxExecutionRequest.schema,
-      z.boolean(),
-      optional(z.boolean()),
-      optional(z.boolean()),
-      optional(SimulationOverrides.schema),
-      optional(z.array(schemas.AztecAddress)),
-    )
-    .returns(TxSimulationResult.schema),
-  getNotes: z.function().args(NotesFilterSchema).returns(z.array(UniqueNote.schema)),
-
-  simulateUtility: z
-    .function()
-    .args(
-      z.string(),
-      z.array(z.any()),
-      schemas.AztecAddress,
-      optional(z.array(AuthWitness.schema)),
-      optional(schemas.AztecAddress),
-      optional(z.array(schemas.AztecAddress)),
-    )
-    .returns(UtilitySimulationResult.schema),
-  getPXEInfo: z.function().returns(PXEInfoSchema),
-  getContractMetadata: z.function().args(schemas.AztecAddress).returns(ContractMetadataSchema),
-  getContractClassMetadata: z.function().args(schemas.Fr, optional(z.boolean())).returns(ContractClassMetadataSchema),
-  getPrivateEvents: z
-    .function()
-    .args(schemas.AztecAddress, EventMetadataDefinitionSchema, z.number(), z.number(), z.array(schemas.AztecAddress))
-    .returns(z.array(AbiDecodedSchema)),
-};

package/src/interfaces/slasher.ts

@@ -24,6 +24,7 @@ export interface SlasherConfig {
   slashOffenseExpirationRounds: number; // Number of rounds after which pending offenses expire
   slashMaxPayloadSize: number; // Maximum number of offenses to include in a single slash payload
   slashGracePeriodL2Slots: number; // Number of L2 slots to wait after genesis before slashing for most offenses
+  slashExecuteRoundsLookBack: number; // How many rounds to look back when searching for a round to execute
 }
 
 export const SlasherConfigSchema = z.object({
@@ -44,5 +45,6 @@ export const SlasherConfigSchema = z.object({
   slashMaxPayloadSize: z.number(),
   slashGracePeriodL2Slots: z.number(),
   slashBroadcastedInvalidBlockPenalty: schemas.BigInt,
+  slashExecuteRoundsLookBack: z.number(),
   slashSelfAllowed: z.boolean().optional(),
 }) satisfies ZodFor<SlasherConfig>;

package/src/interfaces/validator.ts

@@ -32,11 +32,14 @@ export interface ValidatorClientConfig {
   /** Interval between polling for new attestations from peers */
   attestationPollingIntervalMs: number;
 
-  /** Re-execute transactions before attesting */
+  /** Whether to re-execute transactions in a block proposal before attesting */
   validatorReexecute: boolean;
 
   /** Will re-execute until this many milliseconds are left in the slot */
   validatorReexecuteDeadlineMs: number;
+
+  /** Whether to always reexecute block proposals, even for non-validator nodes or when out of the currnet committee */
+  alwaysReexecuteBlockProposals?: boolean;
 }
 
 export type ValidatorClientFullConfig = ValidatorClientConfig &
@@ -50,6 +53,7 @@ export const ValidatorClientConfigSchema = z.object({
   attestationPollingIntervalMs: z.number().min(0),
   validatorReexecute: z.boolean(),
   validatorReexecuteDeadlineMs: z.number().min(0),
+  alwaysReexecuteBlockProposals: z.boolean().optional(),
 }) satisfies ZodFor<Omit<ValidatorClientConfig, 'validatorPrivateKeys'>>;
 
 export interface Validator {

package/src/rollup/avm_proof_data.ts

@@ -1,39 +1,10 @@
 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 { ProofData } 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(),
-    );
-  }
-}
+export type AvmProofData = ProofData<AvmCircuitPublicInputs, typeof AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED>;
 
 // TODO(#14234)[Unconditional PIs validation]: remove this function.
 export function enhanceProofWithPiValidationFlag(proof: Fr[], skipPublicInputsValidation: boolean): Fr[] {