@aztec/stdlib 1.2.0 → 2.0.0-nightly.20250813

package/src/block/l2_block_source.ts

@@ -1,15 +1,17 @@
 import type { EthAddress } from '@aztec/foundation/eth-address';
+import { type ZodFor, schemas } from '@aztec/foundation/schemas';
 import type { TypedEventEmitter } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
 import type { L1RollupConstants } from '../epoch-helpers/index.js';
+import { BlockAttestation } from '../p2p/block_attestation.js';
 import type { BlockHeader } from '../tx/block_header.js';
 import type { IndexedTxEffect } from '../tx/indexed_tx_effect.js';
 import type { TxHash } from '../tx/tx_hash.js';
 import type { TxReceipt } from '../tx/tx_receipt.js';
 import type { L2Block } from './l2_block.js';
-import type { PublishedL2Block } from './published_l2_block.js';
+import { PublishedL2Block } from './published_l2_block.js';
 
 /**
  * Interface of classes allowing for the retrieval of L2 blocks.
@@ -122,10 +124,70 @@ export interface L2BlockSource {
   /** Latest synced L1 timestamp. */
   getL1Timestamp(): Promise<bigint>;
 
+  /**
+   * Returns whether the latest block in the pending chain on L1 is invalid (ie its attestations are incorrect).
+   * Note that invalid blocks do not get synced, so the latest block returned by the block source is always a valid one.
+   */
+  isPendingChainInvalid(): Promise<boolean>;
+
+  /**
+   * Returns the status of the pending chain validation. If the chain is invalid, reports the earliest consecutive block
+   * that is invalid, along with the reason for being invalid, which can be used to trigger an invalidation.
+   */
+  getPendingChainValidationStatus(): Promise<ValidateBlockResult>;
+
   /** Force a sync. */
   syncImmediate(): Promise<void>;
 }
 
+/** Subtype for invalid block validation results */
+export type ValidateBlockNegativeResult =
+  | {
+      valid: false;
+      block: PublishedL2Block;
+      committee: EthAddress[];
+      epoch: bigint;
+      seed: bigint;
+      attestations: BlockAttestation[];
+      reason: 'insufficient-attestations';
+    }
+  | {
+      valid: false;
+      block: PublishedL2Block;
+      committee: EthAddress[];
+      epoch: bigint;
+      seed: bigint;
+      reason: 'invalid-attestation';
+      attestations: BlockAttestation[];
+      invalidIndex: number;
+    };
+
+/** Result type for validating a block attestations */
+export type ValidateBlockResult = { valid: true } | ValidateBlockNegativeResult;
+
+export const ValidateBlockResultSchema = z.union([
+  z.object({ valid: z.literal(true), block: PublishedL2Block.schema.optional() }),
+  z.object({
+    valid: z.literal(false),
+    block: PublishedL2Block.schema,
+    committee: z.array(schemas.EthAddress),
+    epoch: schemas.BigInt,
+    seed: schemas.BigInt,
+    attestations: z.array(BlockAttestation.schema),
+    reason: z.literal('insufficient-attestations'),
+  }),
+  z.object({
+    valid: z.literal(false),
+    block: PublishedL2Block.schema,
+    committee: z.array(schemas.EthAddress),
+    epoch: schemas.BigInt,
+    seed: schemas.BigInt,
+    attestations: z.array(BlockAttestation.schema),
+    reason: z.literal('invalid-attestation'),
+    invalidIndex: z.number(),
+  }),
+]) satisfies ZodFor<ValidateBlockResult>;
+
 /**
  * L2BlockSource that emits events upon pending / proven chain changes.
  * see L2BlockSourceEvents for the events emitted.
@@ -134,6 +196,7 @@ export interface L2BlockSource {
 export type ArchiverEmitter = TypedEventEmitter<{
   [L2BlockSourceEvents.L2PruneDetected]: (args: L2BlockPruneEvent) => void;
   [L2BlockSourceEvents.L2BlockProven]: (args: L2BlockProvenEvent) => void;
+  [L2BlockSourceEvents.InvalidAttestationsBlockDetected]: (args: InvalidBlockDetectedEvent) => void;
 }>;
 export interface L2BlockSourceEventEmitter extends L2BlockSource, ArchiverEmitter {}
 
@@ -180,6 +243,7 @@ export const L2TipsSchema = z.object({
 export enum L2BlockSourceEvents {
   L2PruneDetected = 'l2PruneDetected',
   L2BlockProven = 'l2BlockProven',
+  InvalidAttestationsBlockDetected = 'invalidBlockDetected',
 }
 
 export type L2BlockProvenEvent = {
@@ -194,3 +258,8 @@ export type L2BlockPruneEvent = {
   epochNumber: bigint;
   blocks: L2Block[];
 };
+
+export type InvalidBlockDetectedEvent = {
+  type: 'invalidBlockDetected';
+  validationResult: ValidateBlockNegativeResult;
+};

package/src/block/proposal/committee_attestation.ts

@@ -32,11 +32,15 @@ export class CommitteeAttestation {
     return new CommitteeAttestation(address, signature);
   }
 
+  static fromSignature(signature: Signature): CommitteeAttestation {
+    return new CommitteeAttestation(EthAddress.ZERO, signature);
+  }
+
   static fromViem(viem: ViemCommitteeAttestation): CommitteeAttestation {
     return new CommitteeAttestation(EthAddress.fromString(viem.addr), Signature.fromViemSignature(viem.signature));
   }
 
-  static fromBuffer(buffer: Buffer): CommitteeAttestation {
+  static fromBuffer(buffer: Buffer | BufferReader): CommitteeAttestation {
     const reader = BufferReader.asReader(buffer);
     const address = reader.readObject(EthAddress);
     const signature = reader.readObject(Signature);

package/src/block/published_l2_block.ts

@@ -1,4 +1,6 @@
 // Ignoring import issue to fix portable inferred type issue in zod schema
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { randomBigInt } from '@aztec/foundation/crypto';
 import { schemas } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
@@ -22,6 +24,14 @@ export class L1PublishedData {
       blockHash: z.string(),
     });
   }
+
+  static random() {
+    return new L1PublishedData(
+      randomBigInt(1000n) + 1n,
+      BigInt(Math.floor(Date.now() / 1000)),
+      Buffer32.random().toString(),
+    );
+  }
 }
 
 export class PublishedL2Block {
@@ -40,12 +50,11 @@ export class PublishedL2Block {
   }
 }
 
-export function getAttestationsFromPublishedL2Block(block: PublishedL2Block) {
+export function getAttestationsFromPublishedL2Block(
+  block: Pick<PublishedL2Block, 'attestations' | 'block'>,
+): BlockAttestation[] {
   const payload = ConsensusPayload.fromBlock(block.block);
   return block.attestations
     .filter(attestation => !attestation.signature.isEmpty())
-    .map(
-      attestation =>
-        new BlockAttestation(block.block.header.globalVariables.blockNumber, payload, attestation.signature),
-    );
+    .map(attestation => new BlockAttestation(block.block.number, payload, attestation.signature));
 }

package/src/contract/contract_instance.ts

@@ -100,12 +100,12 @@ export class SerializableContractInstance {
 }
 
 /**
- * Generates a Contract Instance from the deployment params.
+ * Generates a Contract Instance from some instantiation params.
  * @param artifact - The account contract build artifact.
- * @param opts - Options for the deployment.
+ * @param opts - Options for the contract's instantiation.
  * @returns - The contract instance
  */
-export async function getContractInstanceFromDeployParams(
+export async function getContractInstanceFromInstantiationParams(
   artifact: ContractArtifact,
   opts: {
     constructorArtifact?: FunctionAbi | string;

package/src/contract/interfaces/protocol_contract_addresses.ts

@@ -3,23 +3,18 @@ import { z } from 'zod';
 import type { AztecAddress } from '../../aztec-address/index.js';
 import { schemas } from '../../schemas/index.js';
 
-export const ProtocolContractsNames = [
-  'classRegisterer',
-  'feeJuice',
-  'instanceDeployer',
-  'multiCallEntrypoint',
-] as const;
+export const ProtocolContractsNames = ['classRegistry', 'feeJuice', 'instanceRegistry', 'multiCallEntrypoint'] as const;
 
 export type ProtocolContractAddresses = {
-  classRegisterer: AztecAddress;
+  classRegistry: AztecAddress;
   feeJuice: AztecAddress;
-  instanceDeployer: AztecAddress;
+  instanceRegistry: AztecAddress;
   multiCallEntrypoint: AztecAddress;
 };
 
 export const ProtocolContractAddressesSchema = z.object({
-  classRegisterer: schemas.AztecAddress,
+  classRegistry: schemas.AztecAddress,
   feeJuice: schemas.AztecAddress,
-  instanceDeployer: schemas.AztecAddress,
+  instanceRegistry: schemas.AztecAddress,
   multiCallEntrypoint: schemas.AztecAddress,
 });

package/src/contract/private_function_membership_proof.ts

@@ -91,7 +91,7 @@ export async function createPrivateFunctionMembershipProof(
 }
 
 /**
- * Verifies that a private function with a membership proof as emitted by the ClassRegisterer contract is valid,
+ * Verifies that a private function with a membership proof as emitted by the ClassRegistry contract is valid,
  * as defined in the protocol specs at contract-deployment/classes:
  *
  * ```

package/src/contract/utility_function_membership_proof.ts

@@ -66,7 +66,7 @@ export async function createUtilityFunctionMembershipProof(
 }
 
 /**
- * Verifies that a utility  function with a membership proof as emitted by the ClassRegisterer contract is valid,
+ * Verifies that a utility  function with a membership proof as emitted by the ClassRegistry contract is valid,
  * as defined in the protocol specs at contract-deployment/classes:
  *
  * ```

package/src/{shared_mutable/shared_mutable_values.ts → delayed_public_mutable/delayed_public_mutable_values.ts}

@@ -6,9 +6,9 @@ import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/
 import { ScheduledDelayChange } from './scheduled_delay_change.js';
 import { ScheduledValueChange } from './scheduled_value_change.js';
 
-export const SHARED_MUTABLE_VALUES_LEN = 2 * UPDATES_VALUE_SIZE + 1;
+export const DELAYED_PUBLIC_MUTABLE_VALUES_LEN = 2 * UPDATES_VALUE_SIZE + 1;
 
-export class SharedMutableValues {
+export class DelayedPublicMutableValues {
   constructor(
     public svc: ScheduledValueChange,
     public sdc: ScheduledDelayChange,
@@ -58,32 +58,32 @@ export class SharedMutableValues {
     return serializeToBuffer(this.toFields());
   }
 
-  static fromBuffer(buffer: Buffer | BufferReader, valueSize: number): SharedMutableValues {
+  static fromBuffer(buffer: Buffer | BufferReader, valueSize: number): DelayedPublicMutableValues {
     const reader = BufferReader.asReader(buffer);
-    return SharedMutableValues.fromFields(reader.readArray(2 * valueSize + 1, Fr));
+    return DelayedPublicMutableValues.fromFields(reader.readArray(2 * valueSize + 1, Fr));
   }
 
   static empty(valueSize: number) {
     return new this(ScheduledValueChange.empty(valueSize), ScheduledDelayChange.empty());
   }
 
-  static async readFromTree(sharedMutableSlot: Fr, readStorage: (storageSlot: Fr) => Promise<Fr>) {
+  static async readFromTree(delayedPublicMutableSlot: Fr, readStorage: (storageSlot: Fr) => Promise<Fr>) {
     const fields = [];
-    for (let i = 0; i < SHARED_MUTABLE_VALUES_LEN; i++) {
-      fields.push(await readStorage(sharedMutableSlot.add(new Fr(i))));
+    for (let i = 0; i < DELAYED_PUBLIC_MUTABLE_VALUES_LEN; i++) {
+      fields.push(await readStorage(delayedPublicMutableSlot.add(new Fr(i))));
     }
-    return SharedMutableValues.fromFields(fields);
+    return DelayedPublicMutableValues.fromFields(fields);
   }
 
   isEmpty(): boolean {
     return this.svc.isEmpty() && this.sdc.isEmpty();
   }
 
-  async writeToTree(sharedMutableSlot: Fr, storageWrite: (storageSlot: Fr, value: Fr) => Promise<void>) {
+  async writeToTree(delayedPublicMutableSlot: Fr, storageWrite: (storageSlot: Fr, value: Fr) => Promise<void>) {
     const fields = this.toFields();
 
     for (let i = 0; i < fields.length; i++) {
-      await storageWrite(sharedMutableSlot.add(new Fr(i)), fields[i]);
+      await storageWrite(delayedPublicMutableSlot.add(new Fr(i)), fields[i]);
     }
   }
 

package/src/delayed_public_mutable/delayed_public_mutable_values_with_hash.ts

@@ -0,0 +1,38 @@
+import { UPDATED_CLASS_IDS_SLOT } from '@aztec/constants';
+import { Fr } from '@aztec/foundation/fields';
+
+import type { AztecAddress } from '../aztec-address/index.js';
+import { deriveStorageSlotInMap } from '../hash/map_slot.js';
+import { DELAYED_PUBLIC_MUTABLE_VALUES_LEN, DelayedPublicMutableValues } from './delayed_public_mutable_values.js';
+import { ScheduledDelayChange } from './scheduled_delay_change.js';
+import { ScheduledValueChange } from './scheduled_value_change.js';
+
+export class DelayedPublicMutableValuesWithHash {
+  private dpmv: DelayedPublicMutableValues;
+
+  constructor(svc: ScheduledValueChange, sdc: ScheduledDelayChange) {
+    this.dpmv = new DelayedPublicMutableValues(svc, sdc);
+  }
+
+  async toFields(): Promise<Fr[]> {
+    return [...this.dpmv.toFields(), await this.dpmv.hash()];
+  }
+
+  async writeToTree(delayedPublicMutableSlot: Fr, storageWrite: (storageSlot: Fr, value: Fr) => Promise<void>) {
+    const fields = await this.toFields();
+
+    for (let i = 0; i < fields.length; i++) {
+      await storageWrite(delayedPublicMutableSlot.add(new Fr(i)), fields[i]);
+    }
+  }
+
+  static async getContractUpdateSlots(contractAddress: AztecAddress) {
+    const delayedPublicMutableSlot = await deriveStorageSlotInMap(new Fr(UPDATED_CLASS_IDS_SLOT), contractAddress);
+    const delayedPublicMutableHashSlot = delayedPublicMutableSlot.add(new Fr(DELAYED_PUBLIC_MUTABLE_VALUES_LEN));
+
+    return {
+      delayedPublicMutableSlot,
+      delayedPublicMutableHashSlot,
+    };
+  }
+}

package/src/delayed_public_mutable/index.ts

@@ -0,0 +1,4 @@
+export * from './scheduled_delay_change.js';
+export * from './scheduled_value_change.js';
+export * from './delayed_public_mutable_values.js';
+export * from './delayed_public_mutable_values_with_hash.js';

package/src/gas/gas.ts

@@ -28,6 +28,10 @@ export class Gas {
       .transform(Gas.from);
   }
 
+  getSize() {
+    return 4 /* daGas */ + 4 /* l2Gas */;
+  }
+
   clone(): Gas {
     return new Gas(this.daGas, this.l2Gas);
   }

package/src/hash/hash.ts

@@ -1,5 +1,4 @@
 import { GeneratorIndex } from '@aztec/constants';
-import { toBigIntBE } from '@aztec/foundation/bigint-buffer';
 import { poseidon2Hash, poseidon2HashWithSeparator, sha256ToField } from '@aztec/foundation/crypto';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr } from '@aztec/foundation/fields';
@@ -13,9 +12,7 @@ import type { AztecAddress } from '../aztec-address/index.js';
  */
 export async function hashVK(keyAsFields: Fr[]): Promise<Fr> {
   // Should match the implementation in barretenberg/cpp/src/barretenberg/flavor/flavor.hpp > hash()
-  const hash = (await poseidon2Hash(keyAsFields)).toBuffer();
-  // Taking the last 16 bytes (128 bits) of the hash.
-  return new Fr(toBigIntBE(hash.subarray(Fr.SIZE_IN_BYTES - 16)));
+  return await poseidon2Hash(keyAsFields);
 }
 
 /**

package/src/interfaces/archiver.ts

@@ -3,7 +3,7 @@ import type { ApiSchemaFor } from '@aztec/foundation/schemas';
 import { z } from 'zod';
 
 import { L2Block } from '../block/l2_block.js';
-import { type L2BlockSource, L2TipsSchema } from '../block/l2_block_source.js';
+import { type L2BlockSource, L2TipsSchema, ValidateBlockResultSchema } from '../block/l2_block_source.js';
 import { PublishedL2Block } from '../block/published_l2_block.js';
 import {
   ContractClassPublicSchema,
@@ -75,4 +75,6 @@ export const ArchiverApiSchema: ApiSchemaFor<ArchiverApi> = {
   getL1Constants: z.function().args().returns(L1RollupConstantsSchema),
   getL1Timestamp: z.function().args().returns(schemas.BigInt),
   syncImmediate: z.function().args().returns(z.void()),
+  isPendingChainInvalid: z.function().args().returns(z.boolean()),
+  getPendingChainValidationStatus: z.function().args().returns(ValidateBlockResultSchema),
 };

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

@@ -3,25 +3,26 @@ import { createSafeJsonRpcClient, defaultFetch } from '@aztec/foundation/json-rp
 import { z } from 'zod';
 
 import type { ApiSchemaFor } from '../schemas/schemas.js';
+import { type MonitoredSlashPayload, MonitoredSlashPayloadSchema } from '../slashing/index.js';
 import { type ComponentsVersions, getVersioningResponseHandler } from '../versioning/index.js';
 import { type SequencerConfig, SequencerConfigSchema } from './configs.js';
 import { type ProverConfig, ProverConfigSchema } from './prover-client.js';
+import { type SlasherConfig, SlasherConfigSchema } from './slasher.js';
 
 /**
  * Aztec node admin API.
  */
 export interface AztecNodeAdmin {
   /**
-   * Updates the configuration of this node.
-   * @param config - Updated configuration to be merged with the current one.
+   * Retrieves the configuration of this node.
    */
-  setConfig(config: Partial<SequencerConfig & ProverConfig & { maxTxPoolSize: number }>): Promise<void>;
+  getConfig(): Promise<AztecNodeAdminConfig>;
 
   /**
-   * Forces the next block to be built bypassing all time and pending checks.
-   * Useful for testing.
+   * Updates the configuration of this node.
+   * @param config - Updated configuration to be merged with the current one.
    */
-  flushTxs(): Promise<void>;
+  setConfig(config: Partial<AztecNodeAdminConfig>): Promise<void>;
 
   /**
    * Pauses syncing, creates a backup of archiver and world-state databases, and uploads them. Returns immediately.
@@ -41,15 +42,25 @@ export interface AztecNodeAdmin {
 
   /** Resumes archiver and world state syncing. */
   resumeSync(): Promise<void>;
+
+  /** Returns all monitored payloads by the slasher. */
+  getSlasherMonitoredPayloads(): Promise<MonitoredSlashPayload[]>;
 }
 
+export type AztecNodeAdminConfig = SequencerConfig & ProverConfig & SlasherConfig & { maxTxPoolSize: number };
+
+export const AztecNodeAdminConfigSchema = SequencerConfigSchema.merge(ProverConfigSchema)
+  .merge(SlasherConfigSchema)
+  .merge(z.object({ maxTxPoolSize: z.number() }));
+
 export const AztecNodeAdminApiSchema: ApiSchemaFor<AztecNodeAdmin> = {
-  setConfig: z.function().args(SequencerConfigSchema.merge(ProverConfigSchema).partial()).returns(z.void()),
-  flushTxs: z.function().returns(z.void()),
+  getConfig: z.function().returns(AztecNodeAdminConfigSchema),
+  setConfig: z.function().args(AztecNodeAdminConfigSchema.partial()).returns(z.void()),
   startSnapshotUpload: z.function().args(z.string()).returns(z.void()),
   rollbackTo: z.function().args(z.number()).returns(z.void()),
   pauseSync: z.function().returns(z.void()),
   resumeSync: z.function().returns(z.void()),
+  getSlasherMonitoredPayloads: z.function().returns(z.array(MonitoredSlashPayloadSchema)),
 };
 
 export function createAztecNodeAdminClient(

package/src/interfaces/configs.ts

@@ -40,6 +40,18 @@ export interface SequencerConfig {
   enforceTimeTable?: boolean;
   /** How many seconds into an L1 slot we can still send a tx and get it mined. */
   maxL1TxInclusionTimeIntoSlot?: number;
+  /** Used for testing to introduce a fake delay after processing each tx */
+  fakeProcessingDelayPerTxMs?: 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;
 }
 
 export const SequencerConfigSchema = z.object({
@@ -58,4 +70,9 @@ export const SequencerConfigSchema = z.object({
   governanceProposerPayload: schemas.EthAddress.optional(),
   maxL1TxInclusionTimeIntoSlot: z.number().optional(),
   enforceTimeTable: z.boolean().optional(),
+  fakeProcessingDelayPerTxMs: z.number().optional(),
+  attestationPropagationTime: z.number().optional(),
+  skipCollectingAttestations: z.boolean().optional(),
+  secondsBeforeInvalidatingBlockAsCommitteeMember: z.number(),
+  secondsBeforeInvalidatingBlockAsNonCommitteeMember: z.number(),
 }) satisfies ZodFor<SequencerConfig>;

package/src/interfaces/pxe.ts

@@ -125,6 +125,8 @@ export interface PXE {
    * This is called by aztec.js when instantiating a contract in a given address with a mismatching artifact.
    * @param contractAddress - The address of the contract to update.
    * @param artifact - The updated artifact for the contract.
+   * @throws If the artifact's contract class is not found in the PXE or if the contract class is different from
+   * the current one (current one from the point of view of the node to which the PXE is connected).
    */
   updateContract(contractAddress: AztecAddress, artifact: ContractArtifact): Promise<void>;
 
@@ -417,7 +419,7 @@ export interface PXEInfo {
 export interface ContractMetadata {
   contractInstance?: ContractInstanceWithAddress | undefined;
   isContractInitialized: boolean;
-  isContractPubliclyDeployed: boolean;
+  isContractPublished: boolean;
 }
 
 export interface ContractClassMetadata {
@@ -429,7 +431,7 @@ export interface ContractClassMetadata {
 const ContractMetadataSchema = z.object({
   contractInstance: z.union([ContractInstanceWithAddressSchema, z.undefined()]),
   isContractInitialized: z.boolean(),
-  isContractPubliclyDeployed: z.boolean(),
+  isContractPublished: z.boolean(),
 }) satisfies ZodFor<ContractMetadata>;
 
 const ContractClassMetadataSchema = z.object({

package/src/interfaces/server.ts

@@ -1,5 +1,7 @@
 export * from './allowed_element.js';
+export * from './api_limit.js';
 export * from './archiver.js';
+export * from './aztec-node.js';
 export * from './block-builder.js';
 export * from './configs.js';
 export * from './epoch-prover.js';
@@ -17,6 +19,6 @@ export * from './proving-job-source.js';
 export * from './proving-job.js';
 export * from './server_circuit_prover.js';
 export * from './service.js';
-export * from './tx-collector.js';
+export * from './slasher.js';
+export * from './tx_provider.js';
 export * from './world_state.js';
-export * from './api_limit.js';

package/src/interfaces/slasher.ts

@@ -0,0 +1,49 @@
+import type { SecretValue } from '@aztec/foundation/config';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { type ZodFor, schemas } from '@aztec/foundation/schemas';
+
+import { z } from 'zod';
+
+export interface SlasherConfig {
+  slashOverridePayload?: EthAddress;
+  slashPayloadTtlSeconds: number; // TTL for payloads, in seconds
+  slashPruneEnabled: boolean;
+  slashPrunePenalty: bigint;
+  slashPruneMaxPenalty: bigint;
+  slashInvalidBlockEnabled: boolean;
+  slashInvalidBlockPenalty: bigint;
+  slashInvalidBlockMaxPenalty: bigint;
+  slashInactivityEnabled: boolean;
+  slashInactivityCreateTargetPercentage: number; // 0-1, 0.9 means 90%. Must be greater than 0
+  slashInactivitySignalTargetPercentage: number; // 0-1, 0.6 means 60%. Must be greater than 0
+  slashInactivityCreatePenalty: bigint;
+  slashInactivityMaxPenalty: bigint;
+  slashProposerRoundPollingIntervalSeconds: number;
+  slashProposeInvalidAttestationsPenalty: bigint;
+  slashProposeInvalidAttestationsMaxPenalty: bigint;
+  slashAttestDescendantOfInvalidPenalty: bigint;
+  slashAttestDescendantOfInvalidMaxPenalty: bigint;
+  slasherPrivateKey: SecretValue<string | undefined>; // Private key of the slasher account used for creating slash payloads
+}
+
+export const SlasherConfigSchema = z.object({
+  slashOverridePayload: schemas.EthAddress.optional(),
+  slashPayloadTtlSeconds: z.number(),
+  slashPruneEnabled: z.boolean(),
+  slashPrunePenalty: schemas.BigInt,
+  slashPruneMaxPenalty: schemas.BigInt,
+  slashInvalidBlockEnabled: z.boolean(),
+  slashInvalidBlockPenalty: schemas.BigInt,
+  slashInvalidBlockMaxPenalty: schemas.BigInt,
+  slashInactivityEnabled: z.boolean(),
+  slashInactivityCreateTargetPercentage: z.number(),
+  slashInactivitySignalTargetPercentage: z.number(),
+  slashInactivityCreatePenalty: schemas.BigInt,
+  slashInactivityMaxPenalty: schemas.BigInt,
+  slashProposerRoundPollingIntervalSeconds: z.number(),
+  slashProposeInvalidAttestationsPenalty: schemas.BigInt,
+  slashProposeInvalidAttestationsMaxPenalty: schemas.BigInt,
+  slashAttestDescendantOfInvalidPenalty: schemas.BigInt,
+  slashAttestDescendantOfInvalidMaxPenalty: schemas.BigInt,
+  slasherPrivateKey: schemas.SecretValue(z.string().optional()),
+}) satisfies ZodFor<SlasherConfig>;

package/src/interfaces/tx_provider.ts

@@ -0,0 +1,16 @@
+import type { L2Block } from '@aztec/stdlib/block';
+import type { BlockProposal } from '@aztec/stdlib/p2p';
+import { type Tx, TxHash } from '@aztec/stdlib/tx';
+
+import type { PeerId } from '@libp2p/interface';
+
+export interface ITxProvider {
+  getAvailableTxs(txHashes: TxHash[]): Promise<{ txs: Tx[]; missingTxs: TxHash[] }>;
+
+  getTxsForBlockProposal(
+    blockProposal: BlockProposal,
+    opts: { pinnedPeer: PeerId | undefined; deadline: Date },
+  ): Promise<{ txs: Tx[]; missingTxs: TxHash[] }>;
+
+  getTxsForBlock(block: L2Block, opts: { deadline: Date }): Promise<{ txs: Tx[]; missingTxs: TxHash[] }>;
+}