@aztec/stdlib 0.0.1-commit.321f6a9 → 0.0.1-commit.330febf

package/src/block/test/l2_tips_store_test_suite.ts

@@ -10,6 +10,7 @@ import {
   type L2TipId,
 } from '@aztec/stdlib/block';
 import { Checkpoint, L1PublishedData, PublishedCheckpoint } from '@aztec/stdlib/checkpoint';
+import { BlockHeader } from '@aztec/stdlib/tx';
 
 import { expect } from 'vitest';
 
@@ -132,6 +133,7 @@ export function testL2TipsStore(makeTipsStore: () => Promise<L2TipsStore>) {
     await tipsStore.handleBlockStreamEvent({
       type: 'chain-proposed',
       block: { number: BlockNumber(5), hash: new Fr(500).toString() },
+      header: BlockHeader.empty(),
     });
 
     const tips = await tipsStore.getL2Tips();
@@ -145,10 +147,12 @@ export function testL2TipsStore(makeTipsStore: () => Promise<L2TipsStore>) {
     await tipsStore.handleBlockStreamEvent({
       type: 'chain-proposed',
       block: { number: BlockNumber(4), hash: new Fr(400).toString() },
+      header: BlockHeader.empty(),
     });
     await tipsStore.handleBlockStreamEvent({
       type: 'chain-proposed',
       block: { number: BlockNumber(9), hash: new Fr(900).toString() },
+      header: BlockHeader.empty(),
     });
 
     // Both recorded heights resolve; the heights between them were never seen and stay undefined.
@@ -165,6 +169,7 @@ export function testL2TipsStore(makeTipsStore: () => Promise<L2TipsStore>) {
     await tipsStore.handleBlockStreamEvent({
       type: 'chain-proposed',
       block: { number: BlockNumber(9), hash: new Fr(900).toString() },
+      header: BlockHeader.empty(),
     });
 
     // Record sparse witnesses at heights below the tip (e.g. a consumer materializing per-height state).

package/src/config/node-rpc-config.ts

@@ -1,6 +1,7 @@
-import { DEFAULT_MAX_DEBUG_LOG_MEMORY_READS } from '@aztec/constants';
 import { type ConfigMappingsType, numberConfigHelper } from '@aztec/foundation/config';
 
+import { DEFAULT_MAX_DEBUG_LOG_MEMORY_READS } from '../avm/avm.js';
+
 export const nodeRpcConfigMappings: ConfigMappingsType<NodeRPCConfig> = {
   rpcSimulatePublicMaxGasLimit: {
     env: 'RPC_SIMULATE_PUBLIC_MAX_GAS_LIMIT',

package/src/contract/artifact_hash.ts

@@ -6,7 +6,13 @@ import { MerkleTree, MerkleTreeCalculator } from '@aztec/foundation/trees';
 
 import deterministicStringify from 'json-stringify-deterministic';
 
-import { type ContractArtifact, type FunctionArtifact, FunctionSelector, FunctionType } from '../abi/index.js';
+import {
+  type ContractArtifact,
+  type FunctionArtifact,
+  FunctionSelector,
+  FunctionType,
+  getFunctionReturnType,
+} from '../abi/index.js';
 
 const VERSION = 1;
 
@@ -104,8 +110,14 @@ export async function computeFunctionArtifactHash(
   return sha256Fr(Buffer.concat([numToUInt8(VERSION), selector.toBuffer(), metadataHash.toBuffer(), bytecodeHash]));
 }
 
-export function computeFunctionMetadataHash(fn: FunctionArtifact) {
-  return sha256Fr(Buffer.from(deterministicStringify(fn.returnTypes), 'utf8'));
+export function computeFunctionMetadataHash(fn: Pick<FunctionArtifact, 'returnType' | 'returnTypes'>) {
+  // Wrap the type in a list (empty when the function returns nothing) so the hash preimage is identical to
+  // what it was when this hash consumed the deprecated `returnTypes` list. This hash is part of the
+  // artifact hash preimage, which contract class ids commit to - changing it would move the computed
+  // class id and address of every contract, and break artifact validation against already-registered
+  // classes.
+  const returnType = getFunctionReturnType(fn);
+  return sha256Fr(Buffer.from(deterministicStringify(returnType ? [returnType] : []), 'utf8'));
 }
 
 function getLogger() {

package/src/interfaces/api_limit.ts

@@ -2,4 +2,9 @@ export const MAX_RPC_LEN = 100;
 export const MAX_RPC_TXS_LEN = 50;
 export const MAX_RPC_BLOCKS_LEN = 50;
 export const MAX_RPC_CHECKPOINTS_LEN = 50;
+/** Checkpoint data carries no attestations or block bodies, so a page can be larger than a full checkpoint response. */
+export const MAX_RPC_CHECKPOINTS_DATA_LEN = 200;
 export const MAX_LOGS_PER_TAG = 20;
+/** Overrides are written into a public data tree fork before simulation, outside the simulated tx's gas budget. */
+export const MAX_RPC_PUBLIC_STORAGE_OVERRIDES_LEN = 200;
+export const MAX_RPC_CONTRACT_OVERRIDES_LEN = 50;

package/src/interfaces/configs.ts

@@ -49,6 +49,11 @@ export interface SequencerConfig {
   txPublicSetupAllowListExtend?: AllowedElement[];
   /** Payload address to vote for */
   governanceProposerPayload?: EthAddress;
+  /**
+   * Keep signalling the configured governance payload even if a proposal referencing it was already
+   * executed within the lookback window. For payloads deliberately designed to be re-executed.
+   */
+  governanceProposerForcePayloadVote?: boolean;
   /**
    * Minimum block-building time (`min_block_duration`) still worth allocating if the proposer starts
    * late, in seconds.
@@ -150,6 +155,7 @@ export const SequencerConfigSchema = zodFor<SequencerConfig>()(
     acvmBinaryPath: z.string().optional(),
     txPublicSetupAllowListExtend: z.array(AllowedElementSchema).optional(),
     governanceProposerPayload: schemas.EthAddress.optional(),
+    governanceProposerForcePayloadVote: z.boolean().optional(),
     minBlockDuration: z.number().positive().optional(),
     checkpointProposalPrepareTime: z.number().nonnegative().optional(),
     l1PublishingTime: z.number().optional(),

package/src/interfaces/tx_provider.ts

@@ -13,6 +13,10 @@ export interface ITxProvider {
    */
   hasTxs(txHashes: TxHash[]): Promise<boolean[]>;
 
+  /**
+   * Collects the txs for a block proposal from the tx pool, the proposal body, and the network.
+   * @throws InvalidBlockProposalTxsError - If a tx carried in the proposal fails minimum integrity validation.
+   */
   getTxsForBlockProposal(
     blockProposal: BlockProposal,
     blockNumber: number,

package/src/kernel/private_kernel_reset_dimensions.ts

@@ -78,7 +78,7 @@ export interface ResetCatalogEntry {
   cost: number;
 }
 
-// Must match the config in noir-projects/noir-protocol-circuits/private_kernel_reset_config.json
+// Must match the shipped private_kernel_reset_config.json, loaded by @aztec/noir-protocol-circuits-types.
 export interface PrivateKernelResetDimensionsConfig {
   // Variants used for mid-tx resets that prevent overflow. Never the last kernel in the chain.
   inner: ResetCatalogEntry[];

package/src/logs/logs_query.ts

@@ -33,8 +33,8 @@ export type LogsQueryBase = {
    */
   txHash?: TxHash;
   /**
-   * Reorg-safety anchor: the latest block hash the caller has synced to. If set and the block is no
-   * longer present, the call throws. Distinct from `toBlock`, which is a filter, not a safety check.
+   * Reorg-safety anchor: the latest block hash the caller has synced to. The call throws if that block is no longer
+   * present. Results are capped at that block, and `toBlock` can only narrow the range further, never past it.
    */
   referenceBlock?: BlockHash;
   /** When set, each log also carries `noteHashes` and all `nullifiers` for note-nonce discovery. */

package/src/tx/hashed_values.ts

@@ -28,12 +28,17 @@ export class HashedValues {
   }
 
   static get schema(): ZodFor<HashedValues> {
-    return z
-      .object({
-        values: z.array(schemas.Fr),
-        hash: schemas.Fr,
-      })
-      .transform(HashedValues.from);
+    return HashedValues.schemaFor();
+  }
+
+  /**
+   * Returns a schema that additionally rejects more than `maxValues` values. The bound belongs to the caller
+   * rather than to this class: the same container carries public calldata, private call arguments and authwit
+   * arguments, and those have different limits.
+   */
+  static schemaFor(maxValues?: number): ZodFor<HashedValues> {
+    const values = maxValues === undefined ? z.array(schemas.Fr) : z.array(schemas.Fr).max(maxValues);
+    return z.object({ values, hash: schemas.Fr }).transform(HashedValues.from);
   }
 
   static from(fields: FieldsOf<HashedValues>): HashedValues {

package/src/tx/offchain_effect.ts

@@ -2,7 +2,7 @@ import { Fr } from '@aztec/foundation/curves/bn254';
 
 import type { AztecAddress } from '../aztec-address/index.js';
 
-// The following identifier was copied over from `noir-projects/aztec-nr/aztec/src/messages/offchain_messages.nr`.
+// The following identifier was copied over from `noir-projects/labs/aztec-nr/aztec/src/messages/offchain_messages.nr`.
 // poseidon2hash("aztecnr_offchain_message")
 export const OFFCHAIN_MESSAGE_IDENTIFIER: Fr = new Fr(
   6023466688192654631553769360478808766602235351827869819420284624004071427516n,

package/src/tx/simulated_tx.ts

@@ -9,6 +9,7 @@ import {
 } from '../contract/interfaces/contract_instance.js';
 import { Gas } from '../gas/gas.js';
 import type { GasUsed } from '../gas/gas_used.js';
+import { MAX_RPC_CONTRACT_OVERRIDES_LEN, MAX_RPC_PUBLIC_STORAGE_OVERRIDES_LEN } from '../interfaces/api_limit.js';
 import { type PublicStorageOverride, PublicStorageOverrideSchema } from '../interfaces/public_storage_override.js';
 import { PrivateKernelTailCircuitPublicInputs } from '../kernel/private_kernel_tail_circuit_public_inputs.js';
 import { ChonkProof } from '../proofs/chonk_proof.js';
@@ -50,8 +51,18 @@ export class SimulationOverrides {
   static get schema() {
     return z
       .object({
-        publicStorage: optional(z.array(PublicStorageOverrideSchema)),
-        contracts: optional(z.record(z.string(), z.object({ instance: ContractInstanceWithAddressSchema }))),
+        publicStorage: optional(
+          z.array(PublicStorageOverrideSchema).max(MAX_RPC_PUBLIC_STORAGE_OVERRIDES_LEN, {
+            message: `publicStorage must have at most ${MAX_RPC_PUBLIC_STORAGE_OVERRIDES_LEN} entries`,
+          }),
+        ),
+        contracts: optional(
+          z
+            .record(z.string(), z.object({ instance: ContractInstanceWithAddressSchema }))
+            .refine(contracts => Object.keys(contracts).length <= MAX_RPC_CONTRACT_OVERRIDES_LEN, {
+              message: `contracts must have at most ${MAX_RPC_CONTRACT_OVERRIDES_LEN} entries`,
+            }),
+        ),
       })
       .transform(args => new SimulationOverrides(args));
   }

package/src/tx/tx.ts

@@ -1,4 +1,10 @@
-import { DA_GAS_PER_FIELD, TX_DA_GAS_OVERHEAD } from '@aztec/constants';
+import {
+  DA_GAS_PER_FIELD,
+  MAX_CONTRACT_CLASS_LOGS_PER_TX,
+  MAX_ENQUEUED_CALLS_PER_TX,
+  MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS,
+  TX_DA_GAS_OVERHEAD,
+} from '@aztec/constants';
 import { type BaseBuffer32, Buffer32 } from '@aztec/foundation/buffer';
 import { Fr } from '@aztec/foundation/curves/bn254';
 import type { ZodFor } from '@aztec/foundation/schemas';
@@ -33,6 +39,14 @@ import { TxHash } from './tx_hash.js';
 // with the existing cost.
 const TX_SINK_PRESIZE_BYTES = 131072;
 
+/**
+ * Upper bound on the calldata entries a tx can carry: one per enqueued call, plus one for the teardown call.
+ * The revertible and non-revertible call request arrays are each sized `MAX_ENQUEUED_CALLS_PER_TX`, but the
+ * private tail circuit fills them by partitioning a single array of that size, so their lengths sum to it. The
+ * teardown request is propagated separately and can only be set once.
+ */
+export const MAX_PUBLIC_FUNCTION_CALLDATA_PER_TX = MAX_ENQUEUED_CALLS_PER_TX + 1;
+
 /**
  * The interface of an L2 transaction.
  */
@@ -172,8 +186,10 @@ export class Tx extends Gossipable {
       .object({
         data: PrivateKernelTailCircuitPublicInputs.schema,
         chonkProof: ChonkProof.schema,
-        contractClassLogFields: z.array(ContractClassLogFields.schema),
-        publicFunctionCalldata: z.array(HashedValues.schema),
+        contractClassLogFields: z.array(ContractClassLogFields.schema).max(MAX_CONTRACT_CLASS_LOGS_PER_TX),
+        publicFunctionCalldata: z
+          .array(HashedValues.schemaFor(MAX_FR_CALLDATA_TO_ALL_ENQUEUED_CALLS))
+          .max(MAX_PUBLIC_FUNCTION_CALLDATA_PER_TX),
       })
       .transform(Tx.create);
   }

package/src/validators/errors.ts

@@ -30,6 +30,23 @@ export class TransactionsNotAvailableError extends ValidatorError {
   }
 }
 
+/**
+ * Thrown when a tx carried in a block proposal fails minimum integrity validation (metadata, size, data,
+ * contract instances, or proof). The proposer signs both the tx hashes and the tx objects, so this is
+ * proposer misbehavior rather than a local failure, and callers classify it as an invalid block proposal.
+ */
+export class InvalidBlockProposalTxsError extends ValidatorError {
+  constructor(public readonly invalidTxs: { txHash: TxHash; reasons: string[] }[]) {
+    super(
+      `Invalid txs in block proposal: ${invalidTxs
+        .map(({ txHash, reasons }) => `${txHash} (${reasons.join(', ')})`)
+        .join('; ')}`,
+    );
+    // Set so `isErrorClass` can recognize this error across package instances, where `instanceof` fails.
+    this.name = 'InvalidBlockProposalTxsError';
+  }
+}
+
 export class FailedToReExecuteTransactionsError extends ValidatorError {
   constructor(txHashes: TxHash[]) {
     super(`Failed to re-execute transactions: ${txHashes.join(', ')}`);