@aztec/sequencer-client 0.0.0-test.0

package/dest/sequencer/timetable.js

@@ -0,0 +1,110 @@
+import { createLogger } from '@aztec/aztec.js';
+import { SequencerState } from './utils.js';
+export class SequencerTimetable {
+    ethereumSlotDuration;
+    aztecSlotDuration;
+    maxL1TxInclusionTimeIntoSlot;
+    enforce;
+    metrics;
+    log;
+    /** How late into the slot can we be to start working */ initialTime;
+    /** How long it takes to get ready to start building */ blockPrepareTime;
+    /** How long it takes to for proposals and attestations to travel across the p2p layer (one-way) */ attestationPropagationTime;
+    /** How much time we spend validating and processing a block after building it, and assembling the proposal to send to attestors */ blockValidationTime;
+    /**
+   * How long it takes to get a published block into L1. L1 builders typically accept txs up to 4 seconds into their slot,
+   * but we'll timeout sooner to give it more time to propagate (remember we also have blobs!). Still, when working in anvil,
+   * we can just post in the very last second of the L1 slot and still expect the tx to be accepted.
+   */ l1PublishingTime;
+    constructor(ethereumSlotDuration, aztecSlotDuration, maxL1TxInclusionTimeIntoSlot, enforce = true, metrics, log = createLogger('sequencer:timetable')){
+        this.ethereumSlotDuration = ethereumSlotDuration;
+        this.aztecSlotDuration = aztecSlotDuration;
+        this.maxL1TxInclusionTimeIntoSlot = maxL1TxInclusionTimeIntoSlot;
+        this.enforce = enforce;
+        this.metrics = metrics;
+        this.log = log;
+        this.initialTime = 3;
+        this.blockPrepareTime = 1;
+        this.attestationPropagationTime = 2;
+        this.blockValidationTime = 1;
+        this.l1PublishingTime = this.ethereumSlotDuration - this.maxL1TxInclusionTimeIntoSlot;
+    }
+    get afterBlockBuildingTimeNeededWithoutReexec() {
+        return this.blockValidationTime + this.attestationPropagationTime * 2 + this.l1PublishingTime;
+    }
+    getBlockProposalExecTimeEnd(secondsIntoSlot) {
+        // We are N seconds into the slot. We need to account for `afterBlockBuildingTimeNeededWithoutReexec` seconds,
+        // send then split the remaining time between the re-execution and the block building.
+        const maxAllowed = this.aztecSlotDuration - this.afterBlockBuildingTimeNeededWithoutReexec;
+        const available = maxAllowed - secondsIntoSlot;
+        const executionTimeEnd = secondsIntoSlot + available / 2;
+        this.log.debug(`Block proposal execution time deadline is ${executionTimeEnd}`, {
+            secondsIntoSlot,
+            maxAllowed,
+            available,
+            executionTimeEnd
+        });
+        return executionTimeEnd;
+    }
+    get afterBlockReexecTimeNeeded() {
+        return this.attestationPropagationTime + this.l1PublishingTime;
+    }
+    getValidatorReexecTimeEnd(secondsIntoSlot) {
+        // We need to leave for `afterBlockReexecTimeNeeded` seconds available.
+        const validationTimeEnd = this.aztecSlotDuration - this.afterBlockReexecTimeNeeded;
+        this.log.debug(`Validator re-execution time deadline is ${validationTimeEnd}`, {
+            secondsIntoSlot,
+            validationTimeEnd
+        });
+        return validationTimeEnd;
+    }
+    getMaxAllowedTime(state) {
+        switch(state){
+            case SequencerState.STOPPED:
+            case SequencerState.IDLE:
+            case SequencerState.SYNCHRONIZING:
+            case SequencerState.PROPOSER_CHECK:
+                return; // We don't really care about times for this states
+            case SequencerState.INITIALIZING_PROPOSAL:
+                return this.initialTime;
+            case SequencerState.CREATING_BLOCK:
+                return this.initialTime + this.blockPrepareTime;
+            case SequencerState.COLLECTING_ATTESTATIONS:
+                return this.aztecSlotDuration - this.l1PublishingTime - 2 * this.attestationPropagationTime;
+            case SequencerState.PUBLISHING_BLOCK:
+                return this.aztecSlotDuration - this.l1PublishingTime;
+            default:
+                {
+                    const _exhaustiveCheck = state;
+                    throw new Error(`Unexpected state: ${state}`);
+                }
+        }
+    }
+    assertTimeLeft(newState, secondsIntoSlot) {
+        if (!this.enforce) {
+            return;
+        }
+        const maxAllowedTime = this.getMaxAllowedTime(newState);
+        if (maxAllowedTime === undefined) {
+            return;
+        }
+        const bufferSeconds = maxAllowedTime - secondsIntoSlot;
+        if (bufferSeconds < 0) {
+            throw new SequencerTooSlowError(newState, maxAllowedTime, secondsIntoSlot);
+        }
+        this.metrics?.recordStateTransitionBufferMs(Math.floor(bufferSeconds * 1000), newState);
+        this.log.trace(`Enough time to transition to ${newState}`, {
+            maxAllowedTime,
+            secondsIntoSlot
+        });
+    }
+}
+export class SequencerTooSlowError extends Error {
+    proposedState;
+    maxAllowedTime;
+    currentTime;
+    constructor(proposedState, maxAllowedTime, currentTime){
+        super(`Too far into slot for ${proposedState} (time into slot ${currentTime}s greater than ${maxAllowedTime}s allowance)`), this.proposedState = proposedState, this.maxAllowedTime = maxAllowedTime, this.currentTime = currentTime;
+        this.name = 'SequencerTooSlowError';
+    }
+}

package/dest/sequencer/utils.d.ts

@@ -0,0 +1,48 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { Signature } from '@aztec/foundation/eth-signature';
+import type { BlockAttestation } from '@aztec/stdlib/p2p';
+export declare enum SequencerState {
+    /**
+     * Sequencer is stopped and not processing any txs from the pool.
+     */
+    STOPPED = "STOPPED",
+    /**
+     * Sequencer is awaiting the next call to work().
+     */
+    IDLE = "IDLE",
+    /**
+     * Synchronizing with the L2 chain.
+     */
+    SYNCHRONIZING = "SYNCHRONIZING",
+    /**
+     * Checking if we are the proposer for the current slot.
+     */
+    PROPOSER_CHECK = "PROPOSER_CHECK",
+    /**
+     * Initializing the block proposal. Will move to CREATING_BLOCK if there are valid txs to include, or back to SYNCHRONIZING otherwise.
+     */
+    INITIALIZING_PROPOSAL = "INITIALIZING_PROPOSAL",
+    /**
+     * Creating a new L2 block. Includes processing public function calls and running rollup circuits. Will move to PUBLISHING_CONTRACT_DATA.
+     */
+    CREATING_BLOCK = "CREATING_BLOCK",
+    /**
+     * Collecting attestations from its peers. Will move to PUBLISHING_BLOCK.
+     */
+    COLLECTING_ATTESTATIONS = "COLLECTING_ATTESTATIONS",
+    /**
+     * Sending the tx to L1 with the L2 block data and awaiting it to be mined. Will move to SYNCHRONIZING.
+     */
+    PUBLISHING_BLOCK = "PUBLISHING_BLOCK"
+}
+export type SequencerStateCallback = () => SequencerState;
+export declare function sequencerStateToNumber(state: SequencerState): number;
+/** Order Attestations
+ *
+ * Returns attestation signatures in the order of a series of provided ethereum addresses
+ * The rollup smart contract expects attestations to appear in the order of the committee
+ *
+ * @todo: perform this logic within the memory attestation store instead?
+ */
+export declare function orderAttestations(attestations: BlockAttestation[], orderAddresses: EthAddress[]): Promise<Signature[]>;
+//# sourceMappingURL=utils.d.ts.map

package/dest/sequencer/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/sequencer/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAE1D,oBAAY,cAAc;IACxB;;OAEG;IACH,OAAO,YAAY;IACnB;;OAEG;IACH,IAAI,SAAS;IACb;;OAEG;IACH,aAAa,kBAAkB;IAC/B;;OAEG;IACH,cAAc,mBAAmB;IACjC;;OAEG;IACH,qBAAqB,0BAA0B;IAC/C;;OAEG;IACH,cAAc,mBAAmB;IACjC;;OAEG;IACH,uBAAuB,4BAA4B;IACnD;;OAEG;IACH,gBAAgB,qBAAqB;CACtC;AAED,MAAM,MAAM,sBAAsB,GAAG,MAAM,cAAc,CAAC;AAE1D,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,CAEpE;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,YAAY,EAAE,gBAAgB,EAAE,EAChC,cAAc,EAAE,UAAU,EAAE,GAC3B,OAAO,CAAC,SAAS,EAAE,CAAC,CAkBtB"}

package/dest/sequencer/utils.js

@@ -0,0 +1,53 @@
+import { Signature } from '@aztec/foundation/eth-signature';
+export var SequencerState = /*#__PURE__*/ function(SequencerState) {
+    /**
+   * Sequencer is stopped and not processing any txs from the pool.
+   */ SequencerState["STOPPED"] = "STOPPED";
+    /**
+   * Sequencer is awaiting the next call to work().
+   */ SequencerState["IDLE"] = "IDLE";
+    /**
+   * Synchronizing with the L2 chain.
+   */ SequencerState["SYNCHRONIZING"] = "SYNCHRONIZING";
+    /**
+   * Checking if we are the proposer for the current slot.
+   */ SequencerState["PROPOSER_CHECK"] = "PROPOSER_CHECK";
+    /**
+   * Initializing the block proposal. Will move to CREATING_BLOCK if there are valid txs to include, or back to SYNCHRONIZING otherwise.
+   */ SequencerState["INITIALIZING_PROPOSAL"] = "INITIALIZING_PROPOSAL";
+    /**
+   * Creating a new L2 block. Includes processing public function calls and running rollup circuits. Will move to PUBLISHING_CONTRACT_DATA.
+   */ SequencerState["CREATING_BLOCK"] = "CREATING_BLOCK";
+    /**
+   * Collecting attestations from its peers. Will move to PUBLISHING_BLOCK.
+   */ SequencerState["COLLECTING_ATTESTATIONS"] = "COLLECTING_ATTESTATIONS";
+    /**
+   * Sending the tx to L1 with the L2 block data and awaiting it to be mined. Will move to SYNCHRONIZING.
+   */ SequencerState["PUBLISHING_BLOCK"] = "PUBLISHING_BLOCK";
+    return SequencerState;
+}({});
+export function sequencerStateToNumber(state) {
+    return Object.values(SequencerState).indexOf(state);
+}
+/** Order Attestations
+ *
+ * Returns attestation signatures in the order of a series of provided ethereum addresses
+ * The rollup smart contract expects attestations to appear in the order of the committee
+ *
+ * @todo: perform this logic within the memory attestation store instead?
+ */ export async function orderAttestations(attestations, orderAddresses) {
+    // Create a map of sender addresses to BlockAttestations
+    const attestationMap = new Map();
+    for (const attestation of attestations){
+        const sender = await attestation.getSender();
+        if (sender) {
+            attestationMap.set(sender.toString(), attestation);
+        }
+    }
+    // Create the ordered array based on the orderAddresses, else return an empty signature
+    const orderedAttestations = orderAddresses.map((address)=>{
+        const addressString = address.toString();
+        return attestationMap.get(addressString)?.signature || Signature.empty();
+    });
+    return orderedAttestations;
+}

package/dest/slasher/factory.d.ts

@@ -0,0 +1,7 @@
+import type { L1ContractsConfig, L1ReaderConfig } from '@aztec/ethereum';
+import type { L2BlockSourceEventEmitter } from '@aztec/stdlib/block';
+import { type TelemetryClient } from '@aztec/telemetry-client';
+import { SlasherClient } from './slasher_client.js';
+import type { SlasherConfig } from './slasher_client.js';
+export declare const createSlasherClient: (_config: SlasherConfig & L1ContractsConfig & L1ReaderConfig, l2BlockSource: L2BlockSourceEventEmitter, telemetry?: TelemetryClient) => SlasherClient;
+//# sourceMappingURL=factory.d.ts.map

package/dest/slasher/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/slasher/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACzE,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AACrE,OAAO,EAAE,KAAK,eAAe,EAAsB,MAAM,yBAAyB,CAAC;AAEnF,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzD,eAAO,MAAM,mBAAmB,YACrB,aAAa,GAAG,iBAAiB,GAAG,cAAc,iBAC5C,yBAAyB,cAC7B,eAAe,kBAI3B,CAAC"}

package/dest/slasher/factory.js

@@ -0,0 +1,8 @@
+import { getTelemetryClient } from '@aztec/telemetry-client';
+import { SlasherClient } from './slasher_client.js';
+export const createSlasherClient = (_config, l2BlockSource, telemetry = getTelemetryClient())=>{
+    const config = {
+        ..._config
+    };
+    return new SlasherClient(config, l2BlockSource, telemetry);
+};

package/dest/slasher/index.d.ts

@@ -0,0 +1,3 @@
+export * from './slasher_client.js';
+export { createSlasherClient } from './factory.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/slasher/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/slasher/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC"}

package/dest/slasher/index.js

@@ -0,0 +1,2 @@
+export * from './slasher_client.js';
+export { createSlasherClient } from './factory.js';

package/dest/slasher/slasher_client.d.ts

@@ -0,0 +1,75 @@
+import { type L1ContractsConfig, type L1ReaderConfig, type ViemPublicClient } from '@aztec/ethereum';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { SlashFactoryAbi } from '@aztec/l1-artifacts';
+import { type L2BlockId, type L2BlockSourceEvent, type L2BlockSourceEventEmitter } from '@aztec/stdlib/block';
+import { type TelemetryClient, WithTracer } from '@aztec/telemetry-client';
+import { type GetContractReturnType } from 'viem';
+/**
+ * Enum defining the possible states of the Slasher client.
+ */
+export declare enum SlasherClientState {
+    IDLE = 0,
+    RUNNING = 1,
+    STOPPED = 2
+}
+/**
+ * The synchronization status of the Slasher client.
+ */
+export interface SlasherSyncState {
+    /**
+     * The current state of the slasher client.
+     */
+    state: SlasherClientState;
+    /**
+     * The block number that the slasher client is synced to.
+     */
+    syncedToL2Block: L2BlockId;
+}
+export interface SlasherConfig {
+    blockCheckIntervalMS: number;
+    blockRequestBatchSize: number;
+}
+/**
+ * @notice A Hypomeiones slasher client implementation
+ *
+ * Hypomeiones: a class of individuals in ancient Sparta who were considered inferior or lesser citizens compared
+ * to the full Spartan citizens.
+ *
+ * The implementation here is less than ideal. It exists, not to be the end all be all, but to show that
+ * slashing can be done with this mechanism.
+ *
+ * The implementation is VERY brute in the sense that it only looks for pruned blocks and then tries to slash
+ * the full committee of that.
+ * If it sees a prune, it will mark the full epoch as "to be slashed".
+ *
+ * Also, it is not particularly smart around what it should if there were to be multiple slashing events.
+ *
+ * A few improvements:
+ * - Only vote on the proposal if it is possible to reach, e.g., if 6 votes are needed and only 4 slots are left don't vote.
+ * - Stop voting on a payload once it is processed.
+ * - Only vote on the proposal if it have not already been executed
+ *  - Caveat, we need to fully decide if it is acceptable to have the same payload address multiple times. In the current
+ *    slash factory that could mean slashing the same committee for the same error multiple times.
+ * - Decide how to deal with multiple slashing events in the same round.
+ *  - This could be that multiple epochs are pruned in the same round, but with the current naive implementation we could end up
+ *    slashing only the first, because the "lifetime" of the second would have passed after that vote
+ */
+export declare class SlasherClient extends WithTracer {
+    private config;
+    private l2BlockSource;
+    private log;
+    private slashEvents;
+    protected slashFactoryContract?: GetContractReturnType<typeof SlashFactoryAbi, ViemPublicClient>;
+    private slashingAmount;
+    constructor(config: SlasherConfig & L1ContractsConfig & L1ReaderConfig, l2BlockSource: L2BlockSourceEventEmitter, telemetry?: TelemetryClient, log?: import("@aztec/foundation/log").Logger);
+    start(): void;
+    getSlashPayload(slotNumber: bigint): Promise<EthAddress | undefined>;
+    handleBlockStreamEvent(event: L2BlockSourceEvent): Promise<void>;
+    /**
+     * Allows consumers to stop the instance of the slasher client.
+     * 'ready' will now return 'false' and the running promise that keeps the client synced is interrupted.
+     */
+    stop(): void;
+    private handlePruneL2Blocks;
+}
+//# sourceMappingURL=slasher_client.d.ts.map

package/dest/slasher/slasher_client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slasher_client.d.ts","sourceRoot":"","sources":["../../src/slasher/slasher_client.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EAEtB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAE3D,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EACL,KAAK,SAAS,EACd,KAAK,kBAAkB,EACvB,KAAK,yBAAyB,EAE/B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,KAAK,eAAe,EAAE,UAAU,EAAsB,MAAM,yBAAyB,CAAC;AAE/F,OAAO,EAAE,KAAK,qBAAqB,EAA+D,MAAM,MAAM,CAAC;AAE/G;;GAEG;AACH,oBAAY,kBAAkB;IAC5B,IAAI,IAAA;IACJ,OAAO,IAAA;IACP,OAAO,IAAA;CACR;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;OAEG;IACH,KAAK,EAAE,kBAAkB,CAAC;IAC1B;;OAEG;IACH,eAAe,EAAE,SAAS,CAAC;CAC5B;AAED,MAAM,WAAW,aAAa;IAC5B,oBAAoB,EAAE,MAAM,CAAC;IAC7B,qBAAqB,EAAE,MAAM,CAAC;CAC/B;AAQD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,aAAc,SAAQ,UAAU;IAWzC,OAAO,CAAC,MAAM;IACd,OAAO,CAAC,aAAa;IAErB,OAAO,CAAC,GAAG;IAbb,OAAO,CAAC,WAAW,CAAoB;IAEvC,SAAS,CAAC,oBAAoB,CAAC,EAAE,qBAAqB,CAAC,OAAO,eAAe,EAAE,gBAAgB,CAAC,CAAa;IAK7G,OAAO,CAAC,cAAc,CAAc;gBAG1B,MAAM,EAAE,aAAa,GAAG,iBAAiB,GAAG,cAAc,EAC1D,aAAa,EAAE,yBAAyB,EAChD,SAAS,GAAE,eAAsC,EACzC,GAAG,yCAA0B;IAwBhC,KAAK;IAMC,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC;IA8B1E,sBAAsB,CAAC,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAavE;;;OAGG;IACI,IAAI;IAOX,OAAO,CAAC,mBAAmB;CAgB5B"}

package/dest/slasher/slasher_client.js

@@ -0,0 +1,132 @@
+import { createEthereumChain } from '@aztec/ethereum';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { createLogger } from '@aztec/foundation/log';
+import { SlashFactoryAbi } from '@aztec/l1-artifacts';
+import { L2BlockSourceEvents } from '@aztec/stdlib/block';
+import { WithTracer, getTelemetryClient } from '@aztec/telemetry-client';
+import { createPublicClient, fallback, getAddress, getContract, http } from 'viem';
+/**
+ * Enum defining the possible states of the Slasher client.
+ */ export var SlasherClientState = /*#__PURE__*/ function(SlasherClientState) {
+    SlasherClientState[SlasherClientState["IDLE"] = 0] = "IDLE";
+    SlasherClientState[SlasherClientState["RUNNING"] = 1] = "RUNNING";
+    SlasherClientState[SlasherClientState["STOPPED"] = 2] = "STOPPED";
+    return SlasherClientState;
+}({});
+/**
+ * @notice A Hypomeiones slasher client implementation
+ *
+ * Hypomeiones: a class of individuals in ancient Sparta who were considered inferior or lesser citizens compared
+ * to the full Spartan citizens.
+ *
+ * The implementation here is less than ideal. It exists, not to be the end all be all, but to show that
+ * slashing can be done with this mechanism.
+ *
+ * The implementation is VERY brute in the sense that it only looks for pruned blocks and then tries to slash
+ * the full committee of that.
+ * If it sees a prune, it will mark the full epoch as "to be slashed".
+ *
+ * Also, it is not particularly smart around what it should if there were to be multiple slashing events.
+ *
+ * A few improvements:
+ * - Only vote on the proposal if it is possible to reach, e.g., if 6 votes are needed and only 4 slots are left don't vote.
+ * - Stop voting on a payload once it is processed.
+ * - Only vote on the proposal if it have not already been executed
+ *  - Caveat, we need to fully decide if it is acceptable to have the same payload address multiple times. In the current
+ *    slash factory that could mean slashing the same committee for the same error multiple times.
+ * - Decide how to deal with multiple slashing events in the same round.
+ *  - This could be that multiple epochs are pruned in the same round, but with the current naive implementation we could end up
+ *    slashing only the first, because the "lifetime" of the second would have passed after that vote
+ */ export class SlasherClient extends WithTracer {
+    config;
+    l2BlockSource;
+    log;
+    slashEvents;
+    slashFactoryContract;
+    // The amount to slash for a prune.
+    // Note that we set it to 0, such that no actual slashing will happen, but the event will be fired,
+    // showing that the slashing mechanism is working.
+    slashingAmount;
+    constructor(config, l2BlockSource, telemetry = getTelemetryClient(), log = createLogger('slasher')){
+        super(telemetry, 'slasher'), this.config = config, this.l2BlockSource = l2BlockSource, this.log = log, this.slashEvents = [], this.slashFactoryContract = undefined, this.slashingAmount = 0n;
+        if (config.l1Contracts.slashFactoryAddress && config.l1Contracts.slashFactoryAddress !== EthAddress.ZERO) {
+            const chain = createEthereumChain(config.l1RpcUrls, config.l1ChainId);
+            const publicClient = createPublicClient({
+                chain: chain.chainInfo,
+                transport: fallback(chain.rpcUrls.map((url)=>http(url))),
+                pollingInterval: config.viemPollingIntervalMS
+            });
+            this.slashFactoryContract = getContract({
+                address: getAddress(config.l1Contracts.slashFactoryAddress.toString()),
+                abi: SlashFactoryAbi,
+                client: publicClient
+            });
+        } else {
+            this.log.warn('No slash factory address found, slashing will not be enabled');
+        }
+        this.log.info(`Slasher client initialized`);
+    }
+    start() {
+        this.log.info('Starting Slasher client...');
+        this.l2BlockSource.on(L2BlockSourceEvents.L2PruneDetected, this.handlePruneL2Blocks.bind(this));
+    }
+    // This is where we should put a bunch of the improvements mentioned earlier.
+    async getSlashPayload(slotNumber) {
+        if (!this.slashFactoryContract) {
+            return undefined;
+        }
+        // As long as the slot is greater than the lifetime, we want to keep deleting the first element
+        // since it will not make sense to include anymore.
+        while(this.slashEvents.length > 0 && this.slashEvents[0].lifetime < slotNumber){
+            this.slashEvents.shift();
+        }
+        if (this.slashEvents.length == 0) {
+            return undefined;
+        }
+        const slashEvent = this.slashEvents[0];
+        const [payloadAddress, isDeployed] = await this.slashFactoryContract.read.getAddressAndIsDeployed([
+            slashEvent.epoch,
+            slashEvent.amount
+        ]);
+        if (!isDeployed) {
+            // The proposal cannot be executed until it is deployed
+            this.log.verbose(`Voting on not yet deployed payload: ${payloadAddress}`);
+        }
+        return EthAddress.fromString(payloadAddress);
+    }
+    handleBlockStreamEvent(event) {
+        this.log.debug(`Handling block stream event ${event.type}`);
+        switch(event.type){
+            case L2BlockSourceEvents.L2PruneDetected:
+                this.handlePruneL2Blocks(event);
+                break;
+            default:
+                {
+                    break;
+                }
+        }
+        return Promise.resolve();
+    }
+    /**
+   * Allows consumers to stop the instance of the slasher client.
+   * 'ready' will now return 'false' and the running promise that keeps the client synced is interrupted.
+   */ stop() {
+        this.log.debug('Stopping Slasher client...');
+        this.l2BlockSource.removeListener(L2BlockSourceEvents.L2PruneDetected, this.handlePruneL2Blocks.bind(this));
+        this.log.info('Slasher client stopped.');
+    }
+    // I need to get the slot number from the block that was just pruned
+    handlePruneL2Blocks(event) {
+        const { slotNumber, epochNumber } = event;
+        this.log.info(`Detected chain prune. Punishing the validators at epoch ${epochNumber}`);
+        // Set the lifetime such that we have a full round that we could vote throughout.
+        const slotsIntoRound = slotNumber % BigInt(this.config.slashingRoundSize);
+        const toNext = slotsIntoRound == 0n ? 0n : BigInt(this.config.slashingRoundSize) - slotsIntoRound;
+        const lifetime = slotNumber + toNext + BigInt(this.config.slashingRoundSize);
+        this.slashEvents.push({
+            epoch: epochNumber,
+            amount: this.slashingAmount,
+            lifetime
+        });
+    }
+}

package/dest/test/index.d.ts

@@ -0,0 +1,17 @@
+import type { PublicProcessorFactory } from '@aztec/simulator/server';
+import { SequencerClient } from '../client/sequencer-client.js';
+import type { SequencerPublisher } from '../publisher/sequencer-publisher.js';
+import { Sequencer } from '../sequencer/sequencer.js';
+import type { SequencerTimetable } from '../sequencer/timetable.js';
+declare class TestSequencer_ extends Sequencer {
+    publicProcessorFactory: PublicProcessorFactory;
+    timetable: SequencerTimetable;
+    publisher: SequencerPublisher;
+}
+export type TestSequencer = TestSequencer_;
+declare class TestSequencerClient_ extends SequencerClient {
+    sequencer: TestSequencer;
+}
+export type TestSequencerClient = TestSequencerClient_;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dest/test/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/test/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;AAEtE,OAAO,EAAE,eAAe,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AAC9E,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAC;AACtD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEpE,cAAM,cAAe,SAAQ,SAAS;IACpB,sBAAsB,EAAG,sBAAsB,CAAC;IAChD,SAAS,EAAG,kBAAkB,CAAC;IAC/B,SAAS,EAAG,kBAAkB,CAAC;CAChD;AAED,MAAM,MAAM,aAAa,GAAG,cAAc,CAAC;AAE3C,cAAM,oBAAqB,SAAQ,eAAe;IAChC,SAAS,EAAG,aAAa,CAAC;CAC3C;AAED,MAAM,MAAM,mBAAmB,GAAG,oBAAoB,CAAC"}

package/dest/test/index.js

@@ -0,0 +1,10 @@
+import { SequencerClient } from '../client/sequencer-client.js';
+import { Sequencer } from '../sequencer/sequencer.js';
+class TestSequencer_ extends Sequencer {
+    publicProcessorFactory;
+    timetable;
+    publisher;
+}
+class TestSequencerClient_ extends SequencerClient {
+    sequencer;
+}

package/dest/tx_validator/archive_cache.d.ts

@@ -0,0 +1,14 @@
+import type { Fr } from '@aztec/foundation/fields';
+import type { ArchiveSource } from '@aztec/p2p';
+import type { MerkleTreeReadOperations } from '@aztec/stdlib/interfaces/server';
+/**
+ * Implements an archive source by checking a DB and an in-memory collection.
+ * Intended for validating transactions as they are added to a block.
+ */
+export declare class ArchiveCache implements ArchiveSource {
+    private db;
+    archives: Map<string, bigint>;
+    constructor(db: MerkleTreeReadOperations);
+    getArchiveIndices(archives: Fr[]): Promise<(bigint | undefined)[]>;
+}
+//# sourceMappingURL=archive_cache.d.ts.map

package/dest/tx_validator/archive_cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"archive_cache.d.ts","sourceRoot":"","sources":["../../src/tx_validator/archive_cache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AACnD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAChD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAGhF;;;GAGG;AACH,qBAAa,YAAa,YAAW,aAAa;IAGpC,OAAO,CAAC,EAAE;IAFtB,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;gBAEV,EAAE,EAAE,wBAAwB;IAInC,iBAAiB,CAAC,QAAQ,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,CAAC;CAWhF"}

package/dest/tx_validator/archive_cache.js

@@ -0,0 +1,22 @@
+import { MerkleTreeId } from '@aztec/stdlib/trees';
+/**
+ * Implements an archive source by checking a DB and an in-memory collection.
+ * Intended for validating transactions as they are added to a block.
+ */ export class ArchiveCache {
+    db;
+    archives;
+    constructor(db){
+        this.db = db;
+        this.archives = new Map();
+    }
+    async getArchiveIndices(archives) {
+        const toCheckDb = archives.filter((n)=>!this.archives.has(n.toString()));
+        const dbHits = await this.db.findLeafIndices(MerkleTreeId.ARCHIVE, toCheckDb);
+        dbHits.forEach((x, index)=>{
+            if (x !== undefined) {
+                this.archives.set(toCheckDb[index].toString(), x);
+            }
+        });
+        return archives.map((n)=>this.archives.get(n.toString()));
+    }
+}

package/dest/tx_validator/gas_validator.d.ts

@@ -0,0 +1,14 @@
+import { Fr } from '@aztec/foundation/fields';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { GasFees } from '@aztec/stdlib/gas';
+import { type Tx, type TxValidationResult, type TxValidator } from '@aztec/stdlib/tx';
+/** Provides a view into public contract state */
+export interface PublicStateSource {
+    storageRead: (contractAddress: AztecAddress, slot: Fr) => Promise<Fr>;
+}
+export declare class GasTxValidator implements TxValidator<Tx> {
+    #private;
+    constructor(publicDataSource: PublicStateSource, feeJuiceAddress: AztecAddress, gasFees: GasFees);
+    validateTx(tx: Tx): Promise<TxValidationResult>;
+}
+//# sourceMappingURL=gas_validator.d.ts.map

package/dest/tx_validator/gas_validator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gas_validator.d.ts","sourceRoot":"","sources":["../../src/tx_validator/gas_validator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAK9C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAChE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,KAAK,EAAE,EAAoB,KAAK,kBAAkB,EAAE,KAAK,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAExG,iDAAiD;AACjD,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,CAAC,eAAe,EAAE,YAAY,EAAE,IAAI,EAAE,EAAE,KAAK,OAAO,CAAC,EAAE,CAAC,CAAC;CACvE;AAED,qBAAa,cAAe,YAAW,WAAW,CAAC,EAAE,CAAC;;gBAMxC,gBAAgB,EAAE,iBAAiB,EAAE,eAAe,EAAE,YAAY,EAAE,OAAO,EAAE,OAAO;IAM1F,UAAU,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC;CA0EtD"}

package/dest/tx_validator/gas_validator.js

@@ -0,0 +1,78 @@
+import { createLogger } from '@aztec/foundation/log';
+import { computeFeePayerBalanceStorageSlot } from '@aztec/protocol-contracts/fee-juice';
+import { getExecutionRequestsByPhase } from '@aztec/simulator/server';
+import { FunctionSelector } from '@aztec/stdlib/abi';
+import { TxExecutionPhase } from '@aztec/stdlib/tx';
+export class GasTxValidator {
+    #log = createLogger('sequencer:tx_validator:tx_gas');
+    #publicDataSource;
+    #feeJuiceAddress;
+    #gasFees;
+    constructor(publicDataSource, feeJuiceAddress, gasFees){
+        this.#publicDataSource = publicDataSource;
+        this.#feeJuiceAddress = feeJuiceAddress;
+        this.#gasFees = gasFees;
+    }
+    async validateTx(tx) {
+        if (await this.#shouldSkip(tx)) {
+            return Promise.resolve({
+                result: 'skipped',
+                reason: [
+                    'Insufficient fee per gas'
+                ]
+            });
+        }
+        return this.#validateTxFee(tx);
+    }
+    /**
+   * Check whether the tx's max fees are valid for the current block, and skip if not.
+   * We skip instead of invalidating since the tx may become eligible later.
+   * Note that circuits check max fees even if fee payer is unset, so we
+   * keep this validation even if the tx does not pay fees.
+   */ async #shouldSkip(tx) {
+        const gasSettings = tx.data.constants.txContext.gasSettings;
+        // Skip the tx if its max fees are not enough for the current block's gas fees.
+        const maxFeesPerGas = gasSettings.maxFeesPerGas;
+        const notEnoughMaxFees = maxFeesPerGas.feePerDaGas.lt(this.#gasFees.feePerDaGas) || maxFeesPerGas.feePerL2Gas.lt(this.#gasFees.feePerL2Gas);
+        if (notEnoughMaxFees) {
+            this.#log.warn(`Skipping transaction ${await tx.getTxHash()} due to insufficient fee per gas`, {
+                txMaxFeesPerGas: maxFeesPerGas.toInspect(),
+                currentGasFees: this.#gasFees.toInspect()
+            });
+        }
+        return notEnoughMaxFees;
+    }
+    async #validateTxFee(tx) {
+        const feePayer = tx.data.feePayer;
+        // Compute the maximum fee that this tx may pay, based on its gasLimits and maxFeePerGas
+        const feeLimit = tx.data.constants.txContext.gasSettings.getFeeLimit();
+        // Read current balance of the feePayer
+        const initialBalance = await this.#publicDataSource.storageRead(this.#feeJuiceAddress, await computeFeePayerBalanceStorageSlot(feePayer));
+        // If there is a claim in this tx that increases the fee payer balance in Fee Juice, add it to balance
+        const setupFns = getExecutionRequestsByPhase(tx, TxExecutionPhase.SETUP);
+        const increasePublicBalanceSelector = await FunctionSelector.fromSignature('_increase_public_balance((Field),u128)');
+        const claimFunctionCall = setupFns.find((fn)=>fn.callContext.contractAddress.equals(this.#feeJuiceAddress) && fn.callContext.msgSender.equals(this.#feeJuiceAddress) && fn.args.length > 2 && // Public functions get routed through the dispatch function, whose first argument is the target function selector.
+            fn.args[0].equals(increasePublicBalanceSelector.toField()) && fn.args[1].equals(feePayer.toField()) && !fn.callContext.isStaticCall);
+        // The claim amount is at index 2 in the args array because:
+        // - Index 0: Target function selector (due to dispatch routing)
+        // - Index 1: Amount recipient
+        // - Index 2: Amount being claimed
+        const balance = claimFunctionCall ? initialBalance.add(claimFunctionCall.args[2]) : initialBalance;
+        if (balance.lt(feeLimit)) {
+            this.#log.warn(`Rejecting transaction due to not enough fee payer balance`, {
+                feePayer,
+                balance: balance.toBigInt(),
+                feeLimit: feeLimit.toBigInt()
+            });
+            return {
+                result: 'invalid',
+                reason: [
+                    'Insufficient fee payer balance'
+                ]
+            };
+        }
+        return {
+            result: 'valid'
+        };
+    }
+}