@aztec/stdlib 0.0.0-test.0 → 0.0.1-commit.0208eb9

package/dest/interfaces/aztec-node.js

@@ -1,93 +1,103 @@
-import { ARCHIVE_HEIGHT, L1_TO_L2_MSG_TREE_HEIGHT, NOTE_HASH_TREE_HEIGHT, NULLIFIER_TREE_HEIGHT, PUBLIC_DATA_TREE_HEIGHT } from '@aztec/constants';
+import { ARCHIVE_HEIGHT, L1_TO_L2_MSG_TREE_HEIGHT, NOTE_HASH_TREE_HEIGHT } from '@aztec/constants';
 import { L1ContractAddressesSchema } from '@aztec/ethereum/l1-contract-addresses';
-import { createSafeJsonRpcClient, defaultFetch } from '@aztec/foundation/json-rpc/client';
-import { SiblingPath } from '@aztec/foundation/trees';
+import { BlockNumberPositiveSchema, BlockNumberSchema, CheckpointNumberPositiveSchema, EpochNumberSchema } from '@aztec/foundation/branded-types';
+import { createSafeJsonRpcClient, makeFetch } from '@aztec/foundation/json-rpc/client';
+import { MembershipWitness, SiblingPath } from '@aztec/foundation/trees';
 import { z } from 'zod';
-import { inBlockSchemaFor } from '../block/in_block.js';
+import { BlockHash } from '../block/block_hash.js';
+import { BlockParameterSchema } from '../block/block_parameter.js';
+import { CheckpointedL2Block } from '../block/checkpointed_l2_block.js';
+import { dataInBlockSchemaFor } from '../block/in_block.js';
 import { L2Block } from '../block/l2_block.js';
-import { L2BlockNumberSchema } from '../block/l2_block_number.js';
 import { L2TipsSchema } from '../block/l2_block_source.js';
+import { PublishedCheckpoint } from '../checkpoint/published_checkpoint.js';
 import { ContractClassPublicSchema, ContractInstanceWithAddressSchema, NodeInfoSchema, ProtocolContractAddressesSchema } from '../contract/index.js';
 import { GasFees } from '../gas/gas_fees.js';
+import { SiloedTag, Tag, TxScopedL2Log } from '../logs/index.js';
 import { LogFilterSchema } from '../logs/log_filter.js';
-import { PrivateLog } from '../logs/private_log.js';
-import { TxScopedL2Log } from '../logs/tx_scoped_l2_log.js';
 import { optional, schemas } from '../schemas/schemas.js';
 import { MerkleTreeId } from '../trees/merkle_tree_id.js';
 import { NullifierMembershipWitness } from '../trees/nullifier_membership_witness.js';
 import { PublicDataWitness } from '../trees/public_data_witness.js';
-import { BlockHeader, PublicSimulationOutput, Tx, TxHash, TxReceipt, TxValidationResultSchema } from '../tx/index.js';
-import { TxEffect } from '../tx/tx_effect.js';
+import { BlockHeader, PublicSimulationOutput, Tx, TxHash, TxReceipt, TxValidationResultSchema, indexedTxSchema } from '../tx/index.js';
+import { SingleValidatorStatsSchema, ValidatorsStatsSchema } from '../validators/schemas.js';
 import { getVersioningResponseHandler } from '../versioning/index.js';
-import { SequencerConfigSchema } from './configs.js';
+import { AllowedElementSchema } from './allowed_element.js';
+import { MAX_RPC_BLOCKS_LEN, MAX_RPC_CHECKPOINTS_LEN, MAX_RPC_LEN, MAX_RPC_TXS_LEN } from './api_limit.js';
 import { GetContractClassLogsResponseSchema, GetPublicLogsResponseSchema } from './get_logs_response.js';
-import { ProverConfigSchema } from './prover-client.js';
 import { WorldStateSyncStatusSchema } from './world_state.js';
+const MAX_SIGNATURES_PER_REGISTER_CALL = 100;
+const MAX_SIGNATURE_LEN = 10000;
 export const AztecNodeApiSchema = {
     getL2Tips: z.function().args().returns(L2TipsSchema),
     getWorldStateSyncStatus: z.function().args().returns(WorldStateSyncStatusSchema),
-    findLeavesIndexes: z.function().args(L2BlockNumberSchema, z.nativeEnum(MerkleTreeId), z.array(schemas.Fr)).returns(z.array(optional(schemas.BigInt))),
-    findBlockNumbersForIndexes: z.function().args(L2BlockNumberSchema, z.nativeEnum(MerkleTreeId), z.array(schemas.BigInt)).returns(z.array(optional(schemas.BigInt))),
-    findNullifiersIndexesWithBlock: z.function().args(L2BlockNumberSchema, z.array(schemas.Fr)).returns(z.array(optional(inBlockSchemaFor(schemas.BigInt)))),
-    getNullifierSiblingPath: z.function().args(L2BlockNumberSchema, schemas.BigInt).returns(SiblingPath.schemaFor(NULLIFIER_TREE_HEIGHT)),
-    getNoteHashSiblingPath: z.function().args(L2BlockNumberSchema, schemas.BigInt).returns(SiblingPath.schemaFor(NOTE_HASH_TREE_HEIGHT)),
-    getL1ToL2MessageMembershipWitness: z.function().args(L2BlockNumberSchema, schemas.Fr).returns(z.tuple([
+    findLeavesIndexes: z.function().args(BlockParameterSchema, z.nativeEnum(MerkleTreeId), z.array(schemas.Fr).max(MAX_RPC_LEN)).returns(z.array(optional(dataInBlockSchemaFor(schemas.BigInt)))),
+    getNullifierMembershipWitness: z.function().args(BlockParameterSchema, schemas.Fr).returns(NullifierMembershipWitness.schema.optional()),
+    getLowNullifierMembershipWitness: z.function().args(BlockParameterSchema, schemas.Fr).returns(NullifierMembershipWitness.schema.optional()),
+    getPublicDataWitness: z.function().args(BlockParameterSchema, schemas.Fr).returns(PublicDataWitness.schema.optional()),
+    getBlockHashMembershipWitness: z.function().args(BlockParameterSchema, BlockHash.schema).returns(MembershipWitness.schemaFor(ARCHIVE_HEIGHT).optional()),
+    getNoteHashMembershipWitness: z.function().args(BlockParameterSchema, schemas.Fr).returns(MembershipWitness.schemaFor(NOTE_HASH_TREE_HEIGHT).optional()),
+    getL1ToL2MessageMembershipWitness: z.function().args(BlockParameterSchema, schemas.Fr).returns(z.tuple([
         schemas.BigInt,
         SiblingPath.schemaFor(L1_TO_L2_MSG_TREE_HEIGHT)
     ]).optional()),
+    getL1ToL2MessageBlock: z.function().args(schemas.Fr).returns(BlockNumberSchema.optional()),
     isL1ToL2MessageSynced: z.function().args(schemas.Fr).returns(z.boolean()),
-    getL2ToL1MessageMembershipWitness: z.function().args(L2BlockNumberSchema, schemas.Fr).returns(z.tuple([
-        schemas.BigInt,
-        SiblingPath.schema
-    ])),
-    getArchiveSiblingPath: z.function().args(L2BlockNumberSchema, schemas.BigInt).returns(SiblingPath.schemaFor(ARCHIVE_HEIGHT)),
-    getPublicDataSiblingPath: z.function().args(L2BlockNumberSchema, schemas.BigInt).returns(SiblingPath.schemaFor(PUBLIC_DATA_TREE_HEIGHT)),
-    getNullifierMembershipWitness: z.function().args(L2BlockNumberSchema, schemas.Fr).returns(NullifierMembershipWitness.schema.optional()),
-    getLowNullifierMembershipWitness: z.function().args(L2BlockNumberSchema, schemas.Fr).returns(NullifierMembershipWitness.schema.optional()),
-    getPublicDataTreeWitness: z.function().args(L2BlockNumberSchema, schemas.Fr).returns(PublicDataWitness.schema.optional()),
-    getBlock: z.function().args(z.number()).returns(L2Block.schema.optional()),
-    getBlockNumber: z.function().returns(z.number()),
-    getProvenBlockNumber: z.function().returns(z.number()),
+    getL2ToL1Messages: z.function().args(EpochNumberSchema).returns(z.array(z.array(z.array(z.array(schemas.Fr))))),
+    getBlock: z.function().args(BlockParameterSchema).returns(L2Block.schema.optional()),
+    getBlockByHash: z.function().args(BlockHash.schema).returns(L2Block.schema.optional()),
+    getBlockByArchive: z.function().args(schemas.Fr).returns(L2Block.schema.optional()),
+    getBlockNumber: z.function().returns(BlockNumberSchema),
+    getProvenBlockNumber: z.function().returns(BlockNumberSchema),
+    getCheckpointedBlockNumber: z.function().returns(BlockNumberSchema),
     isReady: z.function().returns(z.boolean()),
     getNodeInfo: z.function().returns(NodeInfoSchema),
-    getBlocks: z.function().args(z.number(), z.number()).returns(z.array(L2Block.schema)),
-    getCurrentBaseFees: z.function().returns(GasFees.schema),
+    getBlocks: z.function().args(BlockNumberPositiveSchema, z.number().gt(0).lte(MAX_RPC_BLOCKS_LEN)).returns(z.array(L2Block.schema)),
+    getCheckpoints: z.function().args(CheckpointNumberPositiveSchema, z.number().gt(0).lte(MAX_RPC_CHECKPOINTS_LEN)).returns(z.array(PublishedCheckpoint.schema)),
+    getCheckpointedBlocks: z.function().args(BlockNumberPositiveSchema, z.number().gt(0).lte(MAX_RPC_BLOCKS_LEN)).returns(z.array(CheckpointedL2Block.schema)),
+    getCurrentMinFees: z.function().returns(GasFees.schema),
+    getMaxPriorityFees: z.function().returns(GasFees.schema),
     getNodeVersion: z.function().returns(z.string()),
     getVersion: z.function().returns(z.number()),
     getChainId: z.function().returns(z.number()),
     getL1ContractAddresses: z.function().returns(L1ContractAddressesSchema),
     getProtocolContractAddresses: z.function().returns(ProtocolContractAddressesSchema),
-    registerContractFunctionSignatures: z.function().args(schemas.AztecAddress, z.array(z.string())).returns(z.void()),
-    getPrivateLogs: z.function().args(z.number(), z.number()).returns(z.array(PrivateLog.schema)),
+    registerContractFunctionSignatures: z.function().args(z.array(z.string().max(MAX_SIGNATURE_LEN)).max(MAX_SIGNATURES_PER_REGISTER_CALL)).returns(z.void()),
     getPublicLogs: z.function().args(LogFilterSchema).returns(GetPublicLogsResponseSchema),
     getContractClassLogs: z.function().args(LogFilterSchema).returns(GetContractClassLogsResponseSchema),
-    getLogsByTags: z.function().args(z.array(schemas.Fr)).returns(z.array(z.array(TxScopedL2Log.schema))),
+    getPrivateLogsByTags: z.function().args(z.array(SiloedTag.schema).max(MAX_RPC_LEN), optional(z.number().gte(0)), optional(BlockHash.schema)).returns(z.array(z.array(TxScopedL2Log.schema))),
+    getPublicLogsByTagsFromContract: z.function().args(schemas.AztecAddress, z.array(Tag.schema).max(MAX_RPC_LEN), optional(z.number().gte(0)), optional(BlockHash.schema)).returns(z.array(z.array(TxScopedL2Log.schema))),
     sendTx: z.function().args(Tx.schema).returns(z.void()),
     getTxReceipt: z.function().args(TxHash.schema).returns(TxReceipt.schema),
-    getTxEffect: z.function().args(TxHash.schema).returns(inBlockSchemaFor(TxEffect.schema).optional()),
-    getPendingTxs: z.function().returns(z.array(Tx.schema)),
+    getTxEffect: z.function().args(TxHash.schema).returns(indexedTxSchema().optional()),
+    getPendingTxs: z.function().args(optional(z.number().gte(1).lte(MAX_RPC_TXS_LEN).default(MAX_RPC_TXS_LEN)), optional(TxHash.schema)).returns(z.array(Tx.schema)),
     getPendingTxCount: z.function().returns(z.number()),
     getTxByHash: z.function().args(TxHash.schema).returns(Tx.schema.optional()),
-    getTxsByHash: z.function().args(z.array(TxHash.schema)).returns(z.array(Tx.schema)),
-    getPublicStorageAt: z.function().args(L2BlockNumberSchema, schemas.AztecAddress, schemas.Fr).returns(schemas.Fr),
-    getBlockHeader: z.function().args(optional(L2BlockNumberSchema)).returns(BlockHeader.schema.optional()),
+    getTxsByHash: z.function().args(z.array(TxHash.schema).max(MAX_RPC_TXS_LEN)).returns(z.array(Tx.schema)),
+    getPublicStorageAt: z.function().args(BlockParameterSchema, schemas.AztecAddress, schemas.Fr).returns(schemas.Fr),
+    getBlockHeader: z.function().args(optional(BlockParameterSchema)).returns(BlockHeader.schema.optional()),
+    getBlockHeaderByArchive: z.function().args(schemas.Fr).returns(BlockHeader.schema.optional()),
+    getValidatorsStats: z.function().returns(ValidatorsStatsSchema),
+    getValidatorStats: z.function().args(schemas.EthAddress, optional(schemas.SlotNumber), optional(schemas.SlotNumber)).returns(SingleValidatorStatsSchema.optional()),
     simulatePublicCalls: z.function().args(Tx.schema, optional(z.boolean())).returns(PublicSimulationOutput.schema),
     isValidTx: z.function().args(Tx.schema, optional(z.object({
         isSimulation: optional(z.boolean()),
         skipFeeEnforcement: optional(z.boolean())
     }))).returns(TxValidationResultSchema),
-    setConfig: z.function().args(SequencerConfigSchema.merge(ProverConfigSchema).partial()).returns(z.void()),
     getContractClass: z.function().args(schemas.Fr).returns(ContractClassPublicSchema.optional()),
     getContract: z.function().args(schemas.AztecAddress).returns(ContractInstanceWithAddressSchema.optional()),
-    flushTxs: z.function().returns(z.void()),
     getEncodedEnr: z.function().returns(z.string().optional()),
-    // TODO(#10007): Remove this method
-    addContractClass: z.function().args(ContractClassPublicSchema).returns(z.void())
+    getAllowedPublicSetup: z.function().args().returns(z.array(AllowedElementSchema))
 };
-export function createAztecNodeClient(url, versions = {}, fetch = defaultFetch) {
+export function createAztecNodeClient(url, versions = {}, fetch = makeFetch([
+    1,
+    2,
+    3
+], false), batchWindowMS = 0) {
     return createSafeJsonRpcClient(url, AztecNodeApiSchema, {
         namespaceMethods: 'node',
         fetch,
+        batchWindowMS,
         onResponse: getVersioningResponseHandler(versions)
     });
 }

package/dest/interfaces/block-builder.d.ts

@@ -1,18 +1,25 @@
-import type { Fr } from '@aztec/foundation/fields';
+import type { BlockNumber, CheckpointNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { LoggerBindings } from '@aztec/foundation/log';
 import type { L2Block } from '../block/l2_block.js';
+import type { ChainConfig, SequencerConfig } from '../config/chain-config.js';
+import type { L1RollupConstants } from '../epoch-helpers/index.js';
+import type { Gas } from '../gas/gas.js';
 import type { BlockHeader } from '../tx/block_header.js';
-import type { GlobalVariables } from '../tx/global_variables.js';
-import type { ProcessedTx } from '../tx/processed_tx.js';
+import type { CheckpointGlobalVariables, GlobalVariables } from '../tx/global_variables.js';
+import type { FailedTx, ProcessedTx } from '../tx/processed_tx.js';
+import { Tx } from '../tx/tx.js';
+import type { TxValidator } from '../tx/validator/tx_validator.js';
+import type { MerkleTreeWriteOperations } from './merkle_tree_operations.js';
 import type { ProcessedTxHandler } from './processed-tx-handler.js';
 /** The interface to a block builder. Generates an L2 block out of a set of processed txs. */
-export interface BlockBuilder extends ProcessedTxHandler {
+export interface IBlockFactory extends ProcessedTxHandler {
     /**
      * Prepares to build a new block. Updates the L1 to L2 message tree.
      * @param globalVariables - The global variables for this block.
      * @param l1ToL2Messages - The set of L1 to L2 messages to be included in this block.
-     * @param previousBlockHeader - The header of the previous block.
      */
-    startNewBlock(globalVariables: GlobalVariables, l1ToL2Messages: Fr[], previousBlockHeader: BlockHeader): Promise<void>;
+    startNewBlock(globalVariables: GlobalVariables, l1ToL2Messages: Fr[]): Promise<void>;
     /**
      * Adds all processed txs to the block. Updates world state with the effects from this tx.
      * @param txs - The transactions to be added.
@@ -23,4 +30,43 @@ export interface BlockBuilder extends ProcessedTxHandler {
      */
     setBlockCompleted(expectedBlockHeader?: BlockHeader): Promise<L2Block>;
 }
-//# sourceMappingURL=block-builder.d.ts.map
+export interface PublicProcessorLimits {
+    maxTransactions?: number;
+    maxBlockSize?: number;
+    maxBlockGas?: Gas;
+    maxBlobFields?: number;
+    deadline?: Date;
+}
+export interface PublicProcessorValidator {
+    preprocessValidator?: TxValidator<Tx>;
+    nullifierCache?: {
+        addNullifiers: (nullifiers: Buffer[]) => void;
+    };
+}
+export type FullNodeBlockBuilderConfig = Pick<L1RollupConstants, 'l1GenesisTime' | 'slotDuration'> & Pick<ChainConfig, 'l1ChainId' | 'rollupVersion'> & Pick<SequencerConfig, 'txPublicSetupAllowList' | 'fakeProcessingDelayPerTxMs' | 'fakeThrowAfterProcessingTxCount'>;
+export declare const FullNodeBlockBuilderConfigKeys: (keyof FullNodeBlockBuilderConfig)[];
+/** Thrown when no valid transactions are available to include in a block after processing, and this is not the first block in a checkpoint. */
+export declare class NoValidTxsError extends Error {
+    readonly failedTxs: FailedTx[];
+    constructor(failedTxs: FailedTx[]);
+}
+/** Result of building a block within a checkpoint. */
+export type BuildBlockInCheckpointResult = {
+    block: L2Block;
+    publicGas: Gas;
+    publicProcessorDuration: number;
+    numTxs: number;
+    failedTxs: FailedTx[];
+    usedTxs: Tx[];
+    usedTxBlobFields: number;
+};
+/** Interface for building blocks within a checkpoint context. */
+export interface ICheckpointBlockBuilder {
+    buildBlock(pendingTxs: Iterable<Tx> | AsyncIterable<Tx>, blockNumber: BlockNumber, timestamp: bigint, opts: PublicProcessorLimits): Promise<BuildBlockInCheckpointResult>;
+}
+/** Interface for creating checkpoint builders. */
+export interface ICheckpointsBuilder {
+    getFork(blockNumber: BlockNumber): Promise<MerkleTreeWriteOperations>;
+    startCheckpoint(checkpointNumber: CheckpointNumber, constants: CheckpointGlobalVariables, l1ToL2Messages: Fr[], previousCheckpointOutHashes: Fr[], fork: MerkleTreeWriteOperations, bindings?: LoggerBindings): Promise<ICheckpointBlockBuilder>;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dest/interfaces/block-builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"block-builder.d.ts","sourceRoot":"","sources":["../../src/interfaces/block-builder.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEpE,6FAA6F;AAC7F,MAAM,WAAW,YAAa,SAAQ,kBAAkB;IACtD;;;;;OAKG;IACH,aAAa,CACX,eAAe,EAAE,eAAe,EAChC,cAAc,EAAE,EAAE,EAAE,EACpB,mBAAmB,EAAE,WAAW,GAC/B,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjB;;;OAGG;IACH,MAAM,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE1C;;OAEG;IACH,iBAAiB,CAAC,mBAAmB,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACxE"}
+{"version":3,"file":"block-builder.d.ts","sourceRoot":"","sources":["../../src/interfaces/block-builder.ts"],"names":[],"mappings":"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"}

package/dest/interfaces/block-builder.js

@@ -1 +1,16 @@
-/** The interface to a block builder. Generates an L2 block out of a set of processed txs. */ export { };
+export const FullNodeBlockBuilderConfigKeys = [
+    'l1GenesisTime',
+    'slotDuration',
+    'l1ChainId',
+    'rollupVersion',
+    'txPublicSetupAllowList',
+    'fakeProcessingDelayPerTxMs',
+    'fakeThrowAfterProcessingTxCount'
+];
+/** Thrown when no valid transactions are available to include in a block after processing, and this is not the first block in a checkpoint. */ export class NoValidTxsError extends Error {
+    failedTxs;
+    constructor(failedTxs){
+        super('No valid transactions to include in block'), this.failedTxs = failedTxs;
+        this.name = 'NoValidTxsError';
+    }
+}

package/dest/interfaces/client.d.ts

@@ -1,5 +1,6 @@
-export * from './pxe.js';
 export * from './aztec-node.js';
+export * from './aztec-node-admin.js';
 export * from './private_kernel_prover.js';
 export * from './get_logs_response.js';
-//# sourceMappingURL=client.d.ts.map
+export * from './api_limit.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xpZW50LmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW50ZXJmYWNlcy9jbGllbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLGdCQUFnQixDQUFDIn0=

package/dest/interfaces/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/interfaces/client.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,iBAAiB,CAAC;AAChC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/interfaces/client.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC;AACtC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,gBAAgB,CAAC"}

package/dest/interfaces/client.js

@@ -1,4 +1,5 @@
-export * from './pxe.js';
 export * from './aztec-node.js';
+export * from './aztec-node-admin.js';
 export * from './private_kernel_prover.js';
 export * from './get_logs_response.js';
+export * from './api_limit.js';

package/dest/interfaces/configs.d.ts

@@ -1,34 +1,20 @@
 import type { EthAddress } from '@aztec/foundation/eth-address';
-import type { Fr } from '@aztec/foundation/fields';
+import type { Prettify } from '@aztec/foundation/types';
 import { z } from 'zod';
-import type { FunctionSelector } from '../abi/function_selector.js';
 import type { AztecAddress } from '../aztec-address/index.js';
-import { type ZodFor } from '../schemas/index.js';
-type AllowedInstance = {
-    address: AztecAddress;
-};
-type AllowedInstanceFunction = {
-    address: AztecAddress;
-    selector: FunctionSelector;
-};
-type AllowedClass = {
-    classId: Fr;
-};
-type AllowedClassFunction = {
-    classId: Fr;
-    selector: FunctionSelector;
-};
-export type AllowedElement = AllowedInstance | AllowedInstanceFunction | AllowedClass | AllowedClassFunction;
-/**
- * The sequencer configuration.
- */
+import { type AllowedElement } from './allowed_element.js';
+/** Sequencer configuration */
 export interface SequencerConfig {
     /** The number of ms to wait between polling for pending txs. */
-    transactionPollingIntervalMS?: number;
+    sequencerPollingIntervalMS?: number;
     /** The maximum number of txs to include in a block. */
     maxTxsPerBlock?: number;
     /** The minimum number of txs to include in a block. */
     minTxsPerBlock?: number;
+    /** The minimum number of valid txs (after execution) to include in a block. If not set, falls back to minTxsPerBlock. */
+    minValidTxsPerBlock?: number;
+    /** Whether to publish txs with the block proposals */
+    publishTxsWithProposals?: boolean;
     /** The maximum L2 block gas. */
     maxL2BlockGas?: number;
     /** The maximum DA block gas. */
@@ -42,111 +28,189 @@ export interface SequencerConfig {
     /** The path to the ACVM binary */
     acvmBinaryPath?: string;
     /** The list of functions calls allowed to run in setup */
-    allowedInSetup?: AllowedElement[];
+    txPublicSetupAllowList?: AllowedElement[];
     /** Max block size */
     maxBlockSizeInBytes?: number;
     /** Payload address to vote for */
     governanceProposerPayload?: EthAddress;
     /** Whether to enforce the time table when building blocks */
     enforceTimeTable?: boolean;
-    /** How many seconds into an L1 slot we can still send a tx and get it mined. */
-    maxL1TxInclusionTimeIntoSlot?: number;
+    /** How much time (in seconds) we allow in the slot for publishing the L1 tx. */
+    l1PublishingTime?: number;
+    /** Used for testing to introduce a fake delay after processing each tx */
+    fakeProcessingDelayPerTxMs?: number;
+    /** Used for testing to throw an error after processing N txs */
+    fakeThrowAfterProcessingTxCount?: number;
+    /** How many seconds it takes for proposals and attestations to travel across the p2p layer (one-way) */
+    attestationPropagationTime?: number;
+    /** How many seconds before invalidating a block as a committee member (zero to never invalidate) */
+    secondsBeforeInvalidatingBlockAsCommitteeMember?: number;
+    /** How many seconds before invalidating a block as a non-committee member (zero to never invalidate) */
+    secondsBeforeInvalidatingBlockAsNonCommitteeMember?: number;
+    /** Skip collecting attestations (for testing only) */
+    skipCollectingAttestations?: boolean;
+    /** Do not invalidate the previous block if invalid when we are the proposer (for testing only) */
+    skipInvalidateBlockAsProposer?: boolean;
+    /** Broadcast invalid block proposals with corrupted state (for testing only) */
+    broadcastInvalidBlockProposal?: boolean;
+    /** Inject a fake attestation (for testing only) */
+    injectFakeAttestation?: boolean;
+    /** Whether to run in fisherman mode: builds blocks on every slot for validation without publishing */
+    fishermanMode?: boolean;
+    /** Shuffle attestation ordering to create invalid ordering (for testing only) */
+    shuffleAttestationOrdering?: boolean;
+    /** Duration per block in milliseconds when building multiple blocks per slot (default: undefined = single block per slot) */
+    blockDurationMs?: number;
+    /** Have sequencer build and publish an empty checkpoint if there are no txs */
+    buildCheckpointIfEmpty?: boolean;
+    /** Skip pushing proposed blocks to archiver (default: false) */
+    skipPushProposedBlocksToArchiver?: boolean;
 }
 export declare const SequencerConfigSchema: z.ZodObject<{
-    transactionPollingIntervalMS: z.ZodOptional<z.ZodNumber>;
+    sequencerPollingIntervalMS: z.ZodOptional<z.ZodNumber>;
     maxTxsPerBlock: z.ZodOptional<z.ZodNumber>;
+    minValidTxsPerBlock: z.ZodOptional<z.ZodNumber>;
     minTxsPerBlock: z.ZodOptional<z.ZodNumber>;
     maxL2BlockGas: z.ZodOptional<z.ZodNumber>;
+    publishTxsWithProposals: z.ZodOptional<z.ZodBoolean>;
     maxDABlockGas: z.ZodOptional<z.ZodNumber>;
-    coinbase: z.ZodOptional<ZodFor<EthAddress>>;
-    feeRecipient: z.ZodOptional<ZodFor<AztecAddress>>;
+    coinbase: z.ZodOptional<import("../schemas/index.js").ZodFor<EthAddress>>;
+    feeRecipient: z.ZodOptional<import("../schemas/index.js").ZodFor<AztecAddress>>;
     acvmWorkingDirectory: z.ZodOptional<z.ZodString>;
     acvmBinaryPath: z.ZodOptional<z.ZodString>;
-    allowedInSetup: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
-        address: ZodFor<AztecAddress>;
-        selector: ZodFor<FunctionSelector>;
+    txPublicSetupAllowList: z.ZodOptional<z.ZodArray<z.ZodUnion<[z.ZodObject<{
+        address: import("../schemas/index.js").ZodFor<AztecAddress>;
+        selector: import("../schemas/index.js").ZodFor<import("../abi/function_selector.js").FunctionSelector>;
     }, "strip", z.ZodTypeAny, {
-        selector: FunctionSelector;
         address: AztecAddress;
+        selector: import("../abi/function_selector.js").FunctionSelector;
     }, {
-        selector?: any;
         address?: any;
+        selector?: any;
     }>, z.ZodObject<{
-        address: ZodFor<AztecAddress>;
+        address: import("../schemas/index.js").ZodFor<AztecAddress>;
     }, "strip", z.ZodTypeAny, {
         address: AztecAddress;
     }, {
         address?: any;
     }>, z.ZodObject<{
-        classId: ZodFor<Fr>;
-        selector: ZodFor<FunctionSelector>;
+        classId: import("../schemas/index.js").ZodFor<import("@aztec/foundation/schemas").Fr>;
+        selector: import("../schemas/index.js").ZodFor<import("../abi/function_selector.js").FunctionSelector>;
     }, "strip", z.ZodTypeAny, {
-        selector: FunctionSelector;
-        classId: Fr;
+        classId: import("@aztec/foundation/schemas").Fr;
+        selector: import("../abi/function_selector.js").FunctionSelector;
     }, {
-        selector?: any;
         classId?: any;
+        selector?: any;
     }>, z.ZodObject<{
-        classId: ZodFor<Fr>;
+        classId: import("../schemas/index.js").ZodFor<import("@aztec/foundation/schemas").Fr>;
     }, "strip", z.ZodTypeAny, {
-        classId: Fr;
+        classId: import("@aztec/foundation/schemas").Fr;
     }, {
         classId?: any;
     }>]>, "many">>;
     maxBlockSizeInBytes: z.ZodOptional<z.ZodNumber>;
-    governanceProposerPayload: z.ZodOptional<ZodFor<EthAddress>>;
-    maxL1TxInclusionTimeIntoSlot: z.ZodOptional<z.ZodNumber>;
+    governanceProposerPayload: z.ZodOptional<import("../schemas/index.js").ZodFor<EthAddress>>;
+    l1PublishingTime: z.ZodOptional<z.ZodNumber>;
     enforceTimeTable: z.ZodOptional<z.ZodBoolean>;
+    fakeProcessingDelayPerTxMs: z.ZodOptional<z.ZodNumber>;
+    fakeThrowAfterProcessingTxCount: z.ZodOptional<z.ZodNumber>;
+    attestationPropagationTime: z.ZodOptional<z.ZodNumber>;
+    skipCollectingAttestations: z.ZodOptional<z.ZodBoolean>;
+    skipInvalidateBlockAsProposer: z.ZodOptional<z.ZodBoolean>;
+    secondsBeforeInvalidatingBlockAsCommitteeMember: z.ZodNumber;
+    secondsBeforeInvalidatingBlockAsNonCommitteeMember: z.ZodNumber;
+    broadcastInvalidBlockProposal: z.ZodOptional<z.ZodBoolean>;
+    injectFakeAttestation: z.ZodOptional<z.ZodBoolean>;
+    fishermanMode: z.ZodOptional<z.ZodBoolean>;
+    shuffleAttestationOrdering: z.ZodOptional<z.ZodBoolean>;
+    blockDurationMs: z.ZodOptional<z.ZodNumber>;
+    buildCheckpointIfEmpty: z.ZodOptional<z.ZodBoolean>;
+    skipPushProposedBlocksToArchiver: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
-    coinbase?: EthAddress | undefined;
-    feeRecipient?: AztecAddress | undefined;
-    transactionPollingIntervalMS?: number | undefined;
+    sequencerPollingIntervalMS?: number | undefined;
     maxTxsPerBlock?: number | undefined;
+    minValidTxsPerBlock?: number | undefined;
     minTxsPerBlock?: number | undefined;
     maxL2BlockGas?: number | undefined;
+    publishTxsWithProposals?: boolean | undefined;
     maxDABlockGas?: number | undefined;
+    coinbase?: EthAddress | undefined;
+    feeRecipient?: AztecAddress | undefined;
     acvmWorkingDirectory?: string | undefined;
     acvmBinaryPath?: string | undefined;
-    allowedInSetup?: ({
-        selector: FunctionSelector;
+    txPublicSetupAllowList?: ({
         address: AztecAddress;
+        selector: import("../abi/function_selector.js").FunctionSelector;
     } | {
         address: AztecAddress;
     } | {
-        selector: FunctionSelector;
-        classId: Fr;
+        classId: import("@aztec/foundation/schemas").Fr;
+        selector: import("../abi/function_selector.js").FunctionSelector;
     } | {
-        classId: Fr;
+        classId: import("@aztec/foundation/schemas").Fr;
     })[] | undefined;
     maxBlockSizeInBytes?: number | undefined;
     governanceProposerPayload?: EthAddress | undefined;
-    maxL1TxInclusionTimeIntoSlot?: number | undefined;
+    l1PublishingTime?: number | undefined;
     enforceTimeTable?: boolean | undefined;
+    fakeProcessingDelayPerTxMs?: number | undefined;
+    fakeThrowAfterProcessingTxCount?: number | undefined;
+    attestationPropagationTime?: number | undefined;
+    skipCollectingAttestations?: boolean | undefined;
+    skipInvalidateBlockAsProposer?: boolean | undefined;
+    secondsBeforeInvalidatingBlockAsCommitteeMember: number;
+    secondsBeforeInvalidatingBlockAsNonCommitteeMember: number;
+    broadcastInvalidBlockProposal?: boolean | undefined;
+    injectFakeAttestation?: boolean | undefined;
+    fishermanMode?: boolean | undefined;
+    shuffleAttestationOrdering?: boolean | undefined;
+    blockDurationMs?: number | undefined;
+    buildCheckpointIfEmpty?: boolean | undefined;
+    skipPushProposedBlocksToArchiver?: boolean | undefined;
 }, {
-    coinbase?: any;
-    feeRecipient?: any;
-    transactionPollingIntervalMS?: number | undefined;
+    sequencerPollingIntervalMS?: number | undefined;
     maxTxsPerBlock?: number | undefined;
+    minValidTxsPerBlock?: number | undefined;
     minTxsPerBlock?: number | undefined;
     maxL2BlockGas?: number | undefined;
+    publishTxsWithProposals?: boolean | undefined;
     maxDABlockGas?: number | undefined;
+    coinbase?: any;
+    feeRecipient?: any;
     acvmWorkingDirectory?: string | undefined;
     acvmBinaryPath?: string | undefined;
-    allowedInSetup?: ({
-        selector?: any;
+    txPublicSetupAllowList?: ({
         address?: any;
+        selector?: any;
     } | {
         address?: any;
     } | {
-        selector?: any;
         classId?: any;
+        selector?: any;
     } | {
         classId?: any;
     })[] | undefined;
     maxBlockSizeInBytes?: number | undefined;
     governanceProposerPayload?: any;
-    maxL1TxInclusionTimeIntoSlot?: number | undefined;
+    l1PublishingTime?: number | undefined;
     enforceTimeTable?: boolean | undefined;
+    fakeProcessingDelayPerTxMs?: number | undefined;
+    fakeThrowAfterProcessingTxCount?: number | undefined;
+    attestationPropagationTime?: number | undefined;
+    skipCollectingAttestations?: boolean | undefined;
+    skipInvalidateBlockAsProposer?: boolean | undefined;
+    secondsBeforeInvalidatingBlockAsCommitteeMember: number;
+    secondsBeforeInvalidatingBlockAsNonCommitteeMember: number;
+    broadcastInvalidBlockProposal?: boolean | undefined;
+    injectFakeAttestation?: boolean | undefined;
+    fishermanMode?: boolean | undefined;
+    shuffleAttestationOrdering?: boolean | undefined;
+    blockDurationMs?: number | undefined;
+    buildCheckpointIfEmpty?: boolean | undefined;
+    skipPushProposedBlocksToArchiver?: boolean | undefined;
 }>;
+type SequencerConfigOptionalKeys = 'governanceProposerPayload' | 'blockDurationMs' | 'coinbase' | 'feeRecipient' | 'acvmWorkingDirectory' | 'acvmBinaryPath' | 'fakeProcessingDelayPerTxMs' | 'fakeThrowAfterProcessingTxCount' | 'l1PublishingTime' | 'txPublicSetupAllowList' | 'minValidTxsPerBlock';
+export type ResolvedSequencerConfig = Prettify<Required<Omit<SequencerConfig, SequencerConfigOptionalKeys>> & Pick<SequencerConfig, SequencerConfigOptionalKeys>>;
 export {};
-//# sourceMappingURL=configs.d.ts.map
+//# sourceMappingURL=data:application/json;base64,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

package/dest/interfaces/configs.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"configs.d.ts","sourceRoot":"","sources":["../../src/interfaces/configs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,EAAE,KAAK,MAAM,EAAW,MAAM,qBAAqB,CAAC;AAE3D,KAAK,eAAe,GAAG;IAAE,OAAO,EAAE,YAAY,CAAA;CAAE,CAAC;AACjD,KAAK,uBAAuB,GAAG;IAAE,OAAO,EAAE,YAAY,CAAC;IAAC,QAAQ,EAAE,gBAAgB,CAAA;CAAE,CAAC;AACrF,KAAK,YAAY,GAAG;IAAE,OAAO,EAAE,EAAE,CAAA;CAAE,CAAC;AACpC,KAAK,oBAAoB,GAAG;IAAE,OAAO,EAAE,EAAE,CAAC;IAAC,QAAQ,EAAE,gBAAgB,CAAA;CAAE,CAAC;AAExE,MAAM,MAAM,cAAc,GAAG,eAAe,GAAG,uBAAuB,GAAG,YAAY,GAAG,oBAAoB,CAAC;AAE7G;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,gEAAgE;IAChE,4BAA4B,CAAC,EAAE,MAAM,CAAC;IACtC,uDAAuD;IACvD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,uDAAuD;IACvD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gCAAgC;IAChC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gCAAgC;IAChC,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,iCAAiC;IACjC,QAAQ,CAAC,EAAE,UAAU,CAAC;IACtB,+BAA+B;IAC/B,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,0DAA0D;IAC1D,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,kCAAkC;IAClC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,0DAA0D;IAC1D,cAAc,CAAC,EAAE,cAAc,EAAE,CAAC;IAClC,qBAAqB;IACrB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,kCAAkC;IAClC,yBAAyB,CAAC,EAAE,UAAU,CAAC;IACvC,6DAA6D;IAC7D,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,gFAAgF;IAChF,4BAA4B,CAAC,EAAE,MAAM,CAAC;CACvC;AASD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAeE,CAAC"}
+{"version":3,"file":"configs.d.ts","sourceRoot":"","sources":["../../src/interfaces/configs.ts"],"names":[],"mappings":"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"}