@aztec/stdlib 0.0.1-commit.fce3e4f → 0.0.1-commit.ff7989d6c

package/src/hash/map_slot.ts

@@ -1,5 +1,6 @@
-import { poseidon2Hash } from '@aztec/foundation/crypto';
-import type { Fr } from '@aztec/foundation/fields';
+import { DomainSeparator } from '@aztec/constants';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 /**
  * Computes the resulting storage slot for an entry in a map.
@@ -14,5 +15,5 @@ export function deriveStorageSlotInMap(
     toField: () => Fr;
   },
 ): Promise<Fr> {
-  return poseidon2Hash([mapSlot, key.toField()]);
+  return poseidon2HashWithSeparator([mapSlot, key.toField()], DomainSeparator.PUBLIC_STORAGE_MAP_SLOT);
 }

package/src/interfaces/allowed_element.ts

@@ -1,10 +1,10 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { Fr } from '@aztec/foundation/curves/bn254';
 
 import { z } from 'zod';
 
 import type { FunctionSelector } from '../abi/function_selector.js';
 import type { AztecAddress } from '../aztec-address/index.js';
-import { type ZodFor, schemas } from '../schemas/index.js';
+import { schemas, zodFor } from '../schemas/index.js';
 
 type AllowedInstance = { address: AztecAddress };
 type AllowedInstanceFunction = { address: AztecAddress; selector: FunctionSelector };
@@ -13,9 +13,11 @@ type AllowedClassFunction = { classId: Fr; selector: FunctionSelector };
 
 export type AllowedElement = AllowedInstance | AllowedInstanceFunction | AllowedClass | AllowedClassFunction;
 
-export const AllowedElementSchema = z.union([
-  z.object({ address: schemas.AztecAddress, selector: schemas.FunctionSelector }),
-  z.object({ address: schemas.AztecAddress }),
-  z.object({ classId: schemas.Fr, selector: schemas.FunctionSelector }),
-  z.object({ classId: schemas.Fr }),
-]) satisfies ZodFor<AllowedElement>;
+export const AllowedElementSchema = zodFor<AllowedElement>()(
+  z.union([
+    z.object({ address: schemas.AztecAddress, selector: schemas.FunctionSelector }),
+    z.object({ address: schemas.AztecAddress }),
+    z.object({ classId: schemas.Fr, selector: schemas.FunctionSelector }),
+    z.object({ classId: schemas.Fr }),
+  ]),
+);

package/src/interfaces/api_limit.ts

@@ -1,3 +1,5 @@
 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;
+export const MAX_LOGS_PER_TAG = 10;

package/src/interfaces/archiver.ts

@@ -1,13 +1,18 @@
-import type { L1ContractAddresses } from '@aztec/ethereum';
-import { EpochNumberSchema } from '@aztec/foundation/branded-types';
+import type { L1ContractAddresses } from '@aztec/ethereum/l1-contract-addresses';
+import { BlockNumberSchema, CheckpointNumberSchema, EpochNumberSchema } from '@aztec/foundation/branded-types';
 import type { ApiSchemaFor } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
 
+import { BlockDataSchema } from '../block/block_data.js';
+import { BlockHash } from '../block/block_hash.js';
+import { CheckpointedL2Block } from '../block/checkpointed_l2_block.js';
 import { L2Block } from '../block/l2_block.js';
 import { type L2BlockSource, L2TipsSchema } from '../block/l2_block_source.js';
-import { PublishedL2Block } from '../block/published_l2_block.js';
-import { ValidateBlockResultSchema } from '../block/validate_block_result.js';
+import { ValidateCheckpointResultSchema } from '../block/validate_block_result.js';
+import { Checkpoint } from '../checkpoint/checkpoint.js';
+import { CheckpointDataSchema } from '../checkpoint/checkpoint_data.js';
+import { PublishedCheckpoint } from '../checkpoint/published_checkpoint.js';
 import {
   ContractClassPublicSchema,
   type ContractDataSource,
@@ -15,7 +20,8 @@ import {
 } from '../contract/index.js';
 import { L1RollupConstantsSchema } from '../epoch-helpers/index.js';
 import { LogFilterSchema } from '../logs/log_filter.js';
-import { PrivateLog } from '../logs/private_log.js';
+import { SiloedTag } from '../logs/siloed_tag.js';
+import { Tag } from '../logs/tag.js';
 import { TxScopedL2Log } from '../logs/tx_scoped_l2_log.js';
 import type { L1ToL2MessageSource } from '../messaging/l1_to_l2_message_source.js';
 import { optional, schemas } from '../schemas/schemas.js';
@@ -48,11 +54,14 @@ export type ArchiverSpecificConfig = {
   /** The maximum possible size of the archiver DB in KB. Overwrites the general dataStoreMapSizeKb. */
   archiverStoreMapSizeKb?: number;
 
-  /** Whether to skip validating block attestations (use only for testing). */
-  skipValidateBlockAttestations?: boolean;
-
   /** Maximum allowed drift in seconds between the Ethereum client and current time. */
   maxAllowedEthClientDriftSeconds?: number;
+
+  /** Whether to allow starting the archiver without debug/trace method support on Ethereum hosts */
+  ethereumAllowNoDebugHosts?: boolean;
+
+  /** Skip validating checkpoint attestations (for testing purposes only) */
+  skipValidateCheckpointAttestations?: boolean;
 };
 
 export const ArchiverSpecificConfigSchema = z.object({
@@ -61,8 +70,9 @@ export const ArchiverSpecificConfigSchema = z.object({
   viemPollingIntervalMS: schemas.Integer.optional(),
   maxLogs: schemas.Integer.optional(),
   archiverStoreMapSizeKb: schemas.Integer.optional(),
-  skipValidateBlockAttestations: z.boolean().optional(),
   maxAllowedEthClientDriftSeconds: schemas.Integer.optional(),
+  ethereumAllowNoDebugHosts: z.boolean().optional(),
+  skipValidateCheckpointAttestations: z.boolean().optional(),
 });
 
 export type ArchiverApi = Omit<
@@ -73,37 +83,52 @@ export type ArchiverApi = Omit<
 export const ArchiverApiSchema: ApiSchemaFor<ArchiverApi> = {
   getRollupAddress: z.function().args().returns(schemas.EthAddress),
   getRegistryAddress: z.function().args().returns(schemas.EthAddress),
-  getBlockNumber: z.function().args().returns(schemas.Integer),
-  getProvenBlockNumber: z.function().args().returns(schemas.Integer),
-  getBlock: z.function().args(schemas.Integer).returns(L2Block.schema.optional()),
+  getBlockNumber: z.function().args().returns(BlockNumberSchema),
+  getProvenBlockNumber: z.function().args().returns(BlockNumberSchema),
+  getCheckpointedL2BlockNumber: z.function().args().returns(BlockNumberSchema),
+  getFinalizedL2BlockNumber: z.function().args().returns(BlockNumberSchema),
+  getBlock: z.function().args(BlockNumberSchema).returns(L2Block.schema.optional()),
   getBlockHeader: z
     .function()
-    .args(z.union([schemas.Integer, z.literal('latest')]))
+    .args(z.union([BlockNumberSchema, z.literal('latest')]))
     .returns(BlockHeader.schema.optional()),
-  getBlocks: z
+  getCheckpointedBlock: z.function().args(BlockNumberSchema).returns(CheckpointedL2Block.schema.optional()),
+  getCheckpointedBlocks: z
     .function()
-    .args(schemas.Integer, schemas.Integer, optional(z.boolean()))
-    .returns(z.array(L2Block.schema)),
-  getPublishedBlocks: z
+    .args(BlockNumberSchema, schemas.Integer)
+    .returns(z.array(CheckpointedL2Block.schema)),
+  getBlocks: z.function().args(BlockNumberSchema, schemas.Integer).returns(z.array(L2Block.schema)),
+  getCheckpoints: z
     .function()
-    .args(schemas.Integer, schemas.Integer, optional(z.boolean()))
-    .returns(z.array(PublishedL2Block.schema)),
-  getPublishedBlockByHash: z.function().args(schemas.Fr).returns(PublishedL2Block.schema.optional()),
-  getPublishedBlockByArchive: z.function().args(schemas.Fr).returns(PublishedL2Block.schema.optional()),
-  getBlockHeaderByHash: z.function().args(schemas.Fr).returns(BlockHeader.schema.optional()),
+    .args(CheckpointNumberSchema, schemas.Integer)
+    .returns(z.array(PublishedCheckpoint.schema)),
+  getCheckpointedBlockByHash: z.function().args(BlockHash.schema).returns(CheckpointedL2Block.schema.optional()),
+  getCheckpointedBlockByArchive: z.function().args(schemas.Fr).returns(CheckpointedL2Block.schema.optional()),
+  getBlockHeaderByHash: z.function().args(BlockHash.schema).returns(BlockHeader.schema.optional()),
   getBlockHeaderByArchive: z.function().args(schemas.Fr).returns(BlockHeader.schema.optional()),
+  getBlockData: z.function().args(BlockNumberSchema).returns(BlockDataSchema.optional()),
+  getBlockDataByArchive: z.function().args(schemas.Fr).returns(BlockDataSchema.optional()),
+  getL2Block: z.function().args(BlockNumberSchema).returns(L2Block.schema.optional()),
+  getL2BlockByHash: z.function().args(BlockHash.schema).returns(L2Block.schema.optional()),
+  getL2BlockByArchive: z.function().args(schemas.Fr).returns(L2Block.schema.optional()),
   getTxEffect: z.function().args(TxHash.schema).returns(indexedTxSchema().optional()),
   getSettledTxReceipt: z.function().args(TxHash.schema).returns(TxReceipt.schema.optional()),
   getL2SlotNumber: z.function().args().returns(schemas.SlotNumber.optional()),
   getL2EpochNumber: z.function().args().returns(EpochNumberSchema.optional()),
-  getBlocksForEpoch: z.function().args(EpochNumberSchema).returns(z.array(L2Block.schema)),
-  getBlockHeadersForEpoch: z.function().args(EpochNumberSchema).returns(z.array(BlockHeader.schema)),
+  getCheckpointsForEpoch: z.function().args(EpochNumberSchema).returns(z.array(Checkpoint.schema)),
+  getCheckpointsDataForEpoch: z.function().args(EpochNumberSchema).returns(z.array(CheckpointDataSchema)),
+  getCheckpointedBlocksForEpoch: z.function().args(EpochNumberSchema).returns(z.array(CheckpointedL2Block.schema)),
+  getBlocksForSlot: z.function().args(schemas.SlotNumber).returns(z.array(L2Block.schema)),
+  getCheckpointedBlockHeadersForEpoch: z.function().args(EpochNumberSchema).returns(z.array(BlockHeader.schema)),
   isEpochComplete: z.function().args(EpochNumberSchema).returns(z.boolean()),
   getL2Tips: z.function().args().returns(L2TipsSchema),
-  getPrivateLogs: z.function().args(z.number(), z.number()).returns(z.array(PrivateLog.schema)),
-  getLogsByTags: z
+  getPrivateLogsByTags: z
+    .function()
+    .args(z.array(SiloedTag.schema), optional(z.number().gte(0)))
+    .returns(z.array(z.array(TxScopedL2Log.schema))),
+  getPublicLogsByTagsFromContract: z
     .function()
-    .args(z.array(schemas.Fr))
+    .args(schemas.AztecAddress, z.array(Tag.schema), optional(z.number().gte(0)))
     .returns(z.array(z.array(TxScopedL2Log.schema))),
   getPublicLogs: z.function().args(LogFilterSchema).returns(GetPublicLogsResponseSchema),
   getContractClassLogs: z.function().args(LogFilterSchema).returns(GetContractClassLogsResponseSchema),
@@ -115,7 +140,7 @@ export const ArchiverApiSchema: ApiSchemaFor<ArchiverApi> = {
     .returns(ContractInstanceWithAddressSchema.optional()),
   getContractClassIds: z.function().args().returns(z.array(schemas.Fr)),
   registerContractFunctionSignatures: z.function().args(z.array(z.string())).returns(z.void()),
-  getL1ToL2Messages: z.function().args(schemas.Integer).returns(z.array(schemas.Fr)),
+  getL1ToL2Messages: z.function().args(CheckpointNumberSchema).returns(z.array(schemas.Fr)),
   getL1ToL2MessageIndex: z.function().args(schemas.Fr).returns(schemas.BigInt.optional()),
   getDebugFunctionName: z.function().args(schemas.AztecAddress, schemas.FunctionSelector).returns(optional(z.string())),
   getL1Constants: z.function().args().returns(L1RollupConstantsSchema),
@@ -126,5 +151,5 @@ export const ArchiverApiSchema: ApiSchemaFor<ArchiverApi> = {
   getL1Timestamp: z.function().args().returns(schemas.BigInt.optional()),
   syncImmediate: z.function().args().returns(z.void()),
   isPendingChainInvalid: z.function().args().returns(z.boolean()),
-  getPendingChainValidationStatus: z.function().args().returns(ValidateBlockResultSchema),
+  getPendingChainValidationStatus: z.function().args().returns(ValidateCheckpointResultSchema),
 };

package/src/interfaces/aztec-node-admin.ts

@@ -50,27 +50,51 @@ export interface AztecNodeAdmin {
 
   /** Returns all offenses applicable for the given round. */
   getSlashOffenses(round: bigint | 'all' | 'current'): Promise<Offense[]>;
+
+  /**
+   * Reloads keystore configuration from disk.
+   *
+   * What is updated:
+   * - Validator attester keys
+   * - Coinbase address per validator
+   * - Fee recipient address per validator
+   *
+   * What is NOT updated (requires node restart):
+   * - L1 publisher signers (the funded accounts that send L1 transactions)
+   * - Prover keys
+   * - HA signer PostgreSQL connections
+   *
+   * Notes:
+   * - New validators must use a publisher key that was already configured at node
+   *   startup (or omit the publisher field to fall back to the attester key).
+   *   A validator with an unknown publisher key will cause the reload to be rejected.
+   */
+  reloadKeystore(): Promise<void>;
 }
 
-export type AztecNodeAdminConfig = ValidatorClientFullConfig &
+// L1 contracts are not mutable via admin updates.
+export type AztecNodeAdminConfig = Omit<ValidatorClientFullConfig, 'l1Contracts'> &
   SequencerConfig &
   ProverConfig &
   SlasherConfig &
-  Pick<ArchiverSpecificConfig, 'archiverPollingIntervalMS' | 'skipValidateBlockAttestations' | 'archiverBatchSize'> & {
-    maxTxPoolSize: number;
+  Pick<
+    ArchiverSpecificConfig,
+    'archiverPollingIntervalMS' | 'archiverBatchSize' | 'skipValidateCheckpointAttestations'
+  > & {
+    maxPendingTxCount: number;
   };
 
 export const AztecNodeAdminConfigSchema = SequencerConfigSchema.merge(ProverConfigSchema)
   .merge(SlasherConfigSchema)
-  .merge(ValidatorClientFullConfigSchema)
+  .merge(ValidatorClientFullConfigSchema.omit({ l1Contracts: true }))
   .merge(
     ArchiverSpecificConfigSchema.pick({
       archiverPollingIntervalMS: true,
-      skipValidateBlockAttestations: true,
       archiverBatchSize: true,
+      skipValidateCheckpointAttestations: true,
     }),
   )
-  .merge(z.object({ maxTxPoolSize: z.number() }));
+  .merge(z.object({ maxPendingTxCount: z.number() }));
 
 export const AztecNodeAdminApiSchema: ApiSchemaFor<AztecNodeAdmin> = {
   getConfig: z.function().returns(AztecNodeAdminConfigSchema),
@@ -84,16 +108,19 @@ export const AztecNodeAdminApiSchema: ApiSchemaFor<AztecNodeAdmin> = {
     .function()
     .args(z.union([z.bigint(), z.literal('all'), z.literal('current')]))
     .returns(z.array(OffenseSchema)),
+  reloadKeystore: z.function().returns(z.void()),
 };
 
 export function createAztecNodeAdminClient(
   url: string,
   versions: Partial<ComponentsVersions> = {},
   fetch = defaultFetch,
+  apiKey?: string,
 ): AztecNodeAdmin {
   return createSafeJsonRpcClient<AztecNodeAdmin>(url, AztecNodeAdminApiSchema, {
     namespaceMethods: 'nodeAdmin',
     fetch,
     onResponse: getVersioningResponseHandler(versions),
+    ...(apiKey ? { extraHeaders: { 'x-api-key': apiKey } } : {}),
   });
 }