@aztec/stdlib 2.0.0-nightly.20250822 → 2.0.0-nightly.20250823

package/dest/block/l2_block.d.ts

@@ -94,6 +94,8 @@ export declare class L2Block {
      */
     static empty(): L2Block;
     get number(): number;
+    get slot(): bigint;
+    get timestamp(): bigint;
     /**
      * Returns the block's hash (hash of block header).
      * @returns The block's hash.

package/dest/block/l2_block.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"l2_block.d.ts","sourceRoot":"","sources":["../../src/block/l2_block.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAG9E,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAC/E,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAGjC;;GAEG;AACH,qBAAa,OAAO;IAEhB,2DAA2D;IACpD,OAAO,EAAE,sBAAsB;IACtC,uBAAuB;IAChB,MAAM,EAAE,WAAW;IAC1B,qBAAqB;IACd,IAAI,EAAE,IAAI;IACjB,OAAO,CAAC,SAAS;;IANjB,2DAA2D;IACpD,OAAO,EAAE,sBAAsB;IACtC,uBAAuB;IAChB,MAAM,EAAE,WAAW;IAC1B,qBAAqB;IACd,IAAI,EAAE,IAAI,EACT,SAAS,GAAE,EAAE,GAAG,SAAqB;IAG/C,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAQhB;IAED;;;OAGG;IACH,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY;IAS5C;;;OAGG;IACH,QAAQ;IAIR;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIvC;;;OAGG;IACH,QAAQ,IAAI,MAAM;IAIlB;;;;;;;;OAQG;WACU,MAAM,CACjB,UAAU,EAAE,MAAM,EAClB,WAAW,SAAI,EACf,mBAAmB,SAAI,EACvB,oBAAoB,SAAI,EACxB,MAAM,GAAE,EAAE,GAAG,SAAqB,EAClC,UAAU,GAAE,MAAM,GAAG,SAAqB,EAC1C,UAAU,GAAE,MAAM,GAAG,SAAqB,GACzC,OAAO,CAAC,OAAO,CAAC;IAUnB;;;OAGG;IACH,MAAM,CAAC,KAAK,IAAI,OAAO;IAIvB,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED;;;OAGG;IACU,IAAI,IAAI,OAAO,CAAC,EAAE,CAAC;IAOhC;;;OAGG;IACH,QAAQ;;;;;;;;;IAuBR,WAAW,IAAI,SAAS;IAUxB,MAAM,CAAC,KAAK,EAAE,OAAO;CAGtB;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC"}
+{"version":3,"file":"l2_block.d.ts","sourceRoot":"","sources":["../../src/block/l2_block.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAG9E,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AAC/E,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AACpD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAGjC;;GAEG;AACH,qBAAa,OAAO;IAEhB,2DAA2D;IACpD,OAAO,EAAE,sBAAsB;IACtC,uBAAuB;IAChB,MAAM,EAAE,WAAW;IAC1B,qBAAqB;IACd,IAAI,EAAE,IAAI;IACjB,OAAO,CAAC,SAAS;;IANjB,2DAA2D;IACpD,OAAO,EAAE,sBAAsB;IACtC,uBAAuB;IAChB,MAAM,EAAE,WAAW;IAC1B,qBAAqB;IACd,IAAI,EAAE,IAAI,EACT,SAAS,GAAE,EAAE,GAAG,SAAqB;IAG/C,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAQhB;IAED;;;OAGG;IACH,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY;IAS5C;;;OAGG;IACH,QAAQ;IAIR;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIvC;;;OAGG;IACH,QAAQ,IAAI,MAAM;IAIlB;;;;;;;;OAQG;WACU,MAAM,CACjB,UAAU,EAAE,MAAM,EAClB,WAAW,SAAI,EACf,mBAAmB,SAAI,EACvB,oBAAoB,SAAI,EACxB,MAAM,GAAE,EAAE,GAAG,SAAqB,EAClC,UAAU,GAAE,MAAM,GAAG,SAAqB,EAC1C,UAAU,GAAE,MAAM,GAAG,SAAqB,GACzC,OAAO,CAAC,OAAO,CAAC;IAUnB;;;OAGG;IACH,MAAM,CAAC,KAAK,IAAI,OAAO;IAIvB,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED;;;OAGG;IACU,IAAI,IAAI,OAAO,CAAC,EAAE,CAAC;IAOhC;;;OAGG;IACH,QAAQ;;;;;;;;;IAuBR,WAAW,IAAI,SAAS;IAUxB,MAAM,CAAC,KAAK,EAAE,OAAO;CAGtB;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC"}

package/dest/block/l2_block.js

@@ -75,6 +75,12 @@ import { makeAppendOnlyTreeSnapshot, makeHeader } from './l2_block_code_to_purge
     get number() {
         return this.header.getBlockNumber();
     }
+    get slot() {
+        return this.header.getSlot();
+    }
+    get timestamp() {
+        return this.header.globalVariables.timestamp;
+    }
     /**
    * Returns the block's hash (hash of block header).
    * @returns The block's hash.

package/dest/interfaces/aztec-node-admin.d.ts

@@ -1,7 +1,7 @@
 import { defaultFetch } from '@aztec/foundation/json-rpc/client';
 import { z } from 'zod';
 import type { ApiSchemaFor } from '../schemas/schemas.js';
-import { type MonitoredSlashPayload } from '../slashing/index.js';
+import { type Offense, type SlashPayloadRound } from '../slashing/index.js';
 import { type ComponentsVersions } from '../versioning/index.js';
 import { type SequencerConfig } from './configs.js';
 import { type ProverConfig } from './prover-client.js';
@@ -34,8 +34,10 @@ export interface AztecNodeAdmin {
     pauseSync(): Promise<void>;
     /** Resumes archiver and world state syncing. */
     resumeSync(): Promise<void>;
-    /** Returns all monitored payloads by the slasher. */
-    getSlasherMonitoredPayloads(): Promise<MonitoredSlashPayload[]>;
+    /** Returns all monitored payloads by the slasher for the current round. */
+    getSlashPayloads(): Promise<SlashPayloadRound[]>;
+    /** Returns all offenses applicable for the given round. */
+    getSlashOffenses(round: bigint | 'all' | 'current'): Promise<Offense[]>;
 }
 export type AztecNodeAdminConfig = SequencerConfig & ProverConfig & SlasherConfig & {
     maxTxPoolSize: number;
@@ -105,9 +107,9 @@ export declare const AztecNodeAdminConfigSchema: z.ZodObject<z.objectUtil.extend
     slashPruneEnabled: z.ZodBoolean;
     slashPrunePenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
     slashPruneMaxPenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
-    slashInvalidBlockEnabled: z.ZodBoolean;
-    slashInvalidBlockPenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
-    slashInvalidBlockMaxPenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+    slashBroadcastedInvalidBlockEnabled: z.ZodBoolean;
+    slashBroadcastedInvalidBlockPenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+    slashBroadcastedInvalidBlockMaxPenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
     slashInactivityEnabled: z.ZodBoolean;
     slashInactivityCreateTargetPercentage: z.ZodNumber;
     slashInactivitySignalTargetPercentage: z.ZodNumber;
@@ -118,7 +120,11 @@ export declare const AztecNodeAdminConfigSchema: z.ZodObject<z.objectUtil.extend
     slashProposeInvalidAttestationsMaxPenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
     slashAttestDescendantOfInvalidPenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
     slashAttestDescendantOfInvalidMaxPenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
-    slasherPrivateKey: z.ZodType<import("@aztec/foundation/config").SecretValue<string | undefined>, any, any>;
+    slashUnknownPenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+    slashUnknownMaxPenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+    slashOffenseExpirationRounds: z.ZodNumber;
+    slashMaxPayloadSize: z.ZodNumber;
+    slashGracePeriodL2Slots: z.ZodNumber;
 }>, {
     maxTxPoolSize: z.ZodNumber;
 }>, "strip", z.ZodTypeAny, {
@@ -133,9 +139,9 @@ export declare const AztecNodeAdminConfigSchema: z.ZodObject<z.objectUtil.extend
     slashPruneEnabled: boolean;
     slashPrunePenalty: bigint;
     slashPruneMaxPenalty: bigint;
-    slashInvalidBlockEnabled: boolean;
-    slashInvalidBlockPenalty: bigint;
-    slashInvalidBlockMaxPenalty: bigint;
+    slashBroadcastedInvalidBlockEnabled: boolean;
+    slashBroadcastedInvalidBlockPenalty: bigint;
+    slashBroadcastedInvalidBlockMaxPenalty: bigint;
     slashInactivityEnabled: boolean;
     slashInactivityCreateTargetPercentage: number;
     slashInactivitySignalTargetPercentage: number;
@@ -146,7 +152,11 @@ export declare const AztecNodeAdminConfigSchema: z.ZodObject<z.objectUtil.extend
     slashProposeInvalidAttestationsMaxPenalty: bigint;
     slashAttestDescendantOfInvalidPenalty: bigint;
     slashAttestDescendantOfInvalidMaxPenalty: bigint;
-    slasherPrivateKey: import("@aztec/foundation/config").SecretValue<string | undefined>;
+    slashUnknownPenalty: bigint;
+    slashUnknownMaxPenalty: bigint;
+    slashOffenseExpirationRounds: number;
+    slashMaxPayloadSize: number;
+    slashGracePeriodL2Slots: number;
     maxTxPoolSize: number;
     coinbase?: import("@aztec/foundation/schemas").EthAddress | undefined;
     feeRecipient?: import("../aztec-address/index.js").AztecAddress | undefined;
@@ -191,9 +201,9 @@ export declare const AztecNodeAdminConfigSchema: z.ZodObject<z.objectUtil.extend
     slashPruneEnabled: boolean;
     slashPrunePenalty: string | number | bigint;
     slashPruneMaxPenalty: string | number | bigint;
-    slashInvalidBlockEnabled: boolean;
-    slashInvalidBlockPenalty: string | number | bigint;
-    slashInvalidBlockMaxPenalty: string | number | bigint;
+    slashBroadcastedInvalidBlockEnabled: boolean;
+    slashBroadcastedInvalidBlockPenalty: string | number | bigint;
+    slashBroadcastedInvalidBlockMaxPenalty: string | number | bigint;
     slashInactivityEnabled: boolean;
     slashInactivityCreateTargetPercentage: number;
     slashInactivitySignalTargetPercentage: number;
@@ -204,6 +214,11 @@ export declare const AztecNodeAdminConfigSchema: z.ZodObject<z.objectUtil.extend
     slashProposeInvalidAttestationsMaxPenalty: string | number | bigint;
     slashAttestDescendantOfInvalidPenalty: string | number | bigint;
     slashAttestDescendantOfInvalidMaxPenalty: string | number | bigint;
+    slashUnknownPenalty: string | number | bigint;
+    slashUnknownMaxPenalty: string | number | bigint;
+    slashOffenseExpirationRounds: number;
+    slashMaxPayloadSize: number;
+    slashGracePeriodL2Slots: number;
     maxTxPoolSize: number;
     coinbase?: any;
     feeRecipient?: any;
@@ -236,7 +251,6 @@ export declare const AztecNodeAdminConfigSchema: z.ZodObject<z.objectUtil.extend
     proverId?: any;
     nodeUrl?: string | undefined;
     slashOverridePayload?: string | undefined;
-    slasherPrivateKey?: any;
 }>;
 export declare const AztecNodeAdminApiSchema: ApiSchemaFor<AztecNodeAdmin>;
 export declare function createAztecNodeAdminClient(url: string, versions?: Partial<ComponentsVersions>, fetch?: typeof defaultFetch): AztecNodeAdmin;

package/dest/interfaces/aztec-node-admin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aztec-node-admin.d.ts","sourceRoot":"","sources":["../../src/interfaces/aztec-node-admin.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2B,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAE1F,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,KAAK,qBAAqB,EAA+B,MAAM,sBAAsB,CAAC;AAC/F,OAAO,EAAE,KAAK,kBAAkB,EAAgC,MAAM,wBAAwB,CAAC;AAC/F,OAAO,EAAE,KAAK,eAAe,EAAyB,MAAM,cAAc,CAAC;AAC3E,OAAO,EAAE,KAAK,YAAY,EAAsB,MAAM,oBAAoB,CAAC;AAC3E,OAAO,EAAE,KAAK,aAAa,EAAuB,MAAM,cAAc,CAAC;AAEvE;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,SAAS,IAAI,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAE3C;;;OAGG;IACH,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,oBAAoB,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEhE;;;OAGG;IACH,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAErD;;;;OAIG;IACH,UAAU,CAAC,iBAAiB,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEtE,+CAA+C;IAC/C,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAE3B,gDAAgD;IAChD,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAE5B,qDAAqD;IACrD,2BAA2B,IAAI,OAAO,CAAC,qBAAqB,EAAE,CAAC,CAAC;CACjE;AAED,MAAM,MAAM,oBAAoB,GAAG,eAAe,GAAG,YAAY,GAAG,aAAa,GAAG;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9G,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEU,CAAC;AAElD,eAAO,MAAM,uBAAuB,EAAE,YAAY,CAAC,cAAc,CAQhE,CAAC;AAEF,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,MAAM,EACX,QAAQ,GAAE,OAAO,CAAC,kBAAkB,CAAM,EAC1C,KAAK,sBAAe,GACnB,cAAc,CAMhB"}
+{"version":3,"file":"aztec-node-admin.d.ts","sourceRoot":"","sources":["../../src/interfaces/aztec-node-admin.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2B,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAE1F,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAE,KAAK,OAAO,EAAiB,KAAK,iBAAiB,EAA2B,MAAM,sBAAsB,CAAC;AACpH,OAAO,EAAE,KAAK,kBAAkB,EAAgC,MAAM,wBAAwB,CAAC;AAC/F,OAAO,EAAE,KAAK,eAAe,EAAyB,MAAM,cAAc,CAAC;AAC3E,OAAO,EAAE,KAAK,YAAY,EAAsB,MAAM,oBAAoB,CAAC;AAC3E,OAAO,EAAE,KAAK,aAAa,EAAuB,MAAM,cAAc,CAAC;AAEvE;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,SAAS,IAAI,OAAO,CAAC,oBAAoB,CAAC,CAAC;IAE3C;;;OAGG;IACH,SAAS,CAAC,MAAM,EAAE,OAAO,CAAC,oBAAoB,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEhE;;;OAGG;IACH,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAErD;;;;OAIG;IACH,UAAU,CAAC,iBAAiB,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEtE,+CAA+C;IAC/C,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAE3B,gDAAgD;IAChD,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAE5B,2EAA2E;IAC3E,gBAAgB,IAAI,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAAC;IAEjD,2DAA2D;IAC3D,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;CACzE;AAED,MAAM,MAAM,oBAAoB,GAAG,eAAe,GAAG,YAAY,GAAG,aAAa,GAAG;IAAE,aAAa,EAAE,MAAM,CAAA;CAAE,CAAC;AAE9G,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEU,CAAC;AAElD,eAAO,MAAM,uBAAuB,EAAE,YAAY,CAAC,cAAc,CAYhE,CAAC;AAEF,wBAAgB,0BAA0B,CACxC,GAAG,EAAE,MAAM,EACX,QAAQ,GAAE,OAAO,CAAC,kBAAkB,CAAM,EAC1C,KAAK,sBAAe,GACnB,cAAc,CAMhB"}

package/dest/interfaces/aztec-node-admin.js

@@ -1,6 +1,6 @@
 import { createSafeJsonRpcClient, defaultFetch } from '@aztec/foundation/json-rpc/client';
 import { z } from 'zod';
-import { MonitoredSlashPayloadSchema } from '../slashing/index.js';
+import { OffenseSchema, SlashPayloadRoundSchema } from '../slashing/index.js';
 import { getVersioningResponseHandler } from '../versioning/index.js';
 import { SequencerConfigSchema } from './configs.js';
 import { ProverConfigSchema } from './prover-client.js';
@@ -15,7 +15,12 @@ export const AztecNodeAdminApiSchema = {
     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))
+    getSlashPayloads: z.function().returns(z.array(SlashPayloadRoundSchema)),
+    getSlashOffenses: z.function().args(z.union([
+        z.bigint(),
+        z.literal('all'),
+        z.literal('current')
+    ])).returns(z.array(OffenseSchema))
 };
 export function createAztecNodeAdminClient(url, versions = {}, fetch = defaultFetch) {
     return createSafeJsonRpcClient(url, AztecNodeAdminApiSchema, {

package/dest/interfaces/epoch-prover.d.ts

@@ -23,7 +23,7 @@ export interface EpochProver extends Omit<IBlockFactory, 'setBlockCompleted'> {
     /** Returns the block. */
     setBlockCompleted(blockNumber: number, expectedBlockHeader?: BlockHeader): Promise<L2Block>;
     /** Pads the epoch with empty block roots if needed and blocks until proven. Throws if proving has failed. */
-    finaliseEpoch(): Promise<{
+    finalizeEpoch(): Promise<{
         publicInputs: RootRollupPublicInputs;
         proof: Proof;
         batchedBlobInputs: BatchedBlob;

package/dest/interfaces/slasher.d.ts

@@ -1,15 +1,15 @@
-import type { SecretValue } from '@aztec/foundation/config';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import { z } from 'zod';
+export type SlasherClientType = 'empire' | 'tally';
 export interface SlasherConfig {
     slashOverridePayload?: EthAddress;
     slashPayloadTtlSeconds: number;
     slashPruneEnabled: boolean;
     slashPrunePenalty: bigint;
     slashPruneMaxPenalty: bigint;
-    slashInvalidBlockEnabled: boolean;
-    slashInvalidBlockPenalty: bigint;
-    slashInvalidBlockMaxPenalty: bigint;
+    slashBroadcastedInvalidBlockEnabled: boolean;
+    slashBroadcastedInvalidBlockPenalty: bigint;
+    slashBroadcastedInvalidBlockMaxPenalty: bigint;
     slashInactivityEnabled: boolean;
     slashInactivityCreateTargetPercentage: number;
     slashInactivitySignalTargetPercentage: number;
@@ -20,7 +20,11 @@ export interface SlasherConfig {
     slashProposeInvalidAttestationsMaxPenalty: bigint;
     slashAttestDescendantOfInvalidPenalty: bigint;
     slashAttestDescendantOfInvalidMaxPenalty: bigint;
-    slasherPrivateKey: SecretValue<string | undefined>;
+    slashUnknownPenalty: bigint;
+    slashUnknownMaxPenalty: bigint;
+    slashOffenseExpirationRounds: number;
+    slashMaxPayloadSize: number;
+    slashGracePeriodL2Slots: number;
 }
 export declare const SlasherConfigSchema: z.ZodObject<{
     slashOverridePayload: z.ZodOptional<z.ZodType<EthAddress, any, string>>;
@@ -28,9 +32,9 @@ export declare const SlasherConfigSchema: z.ZodObject<{
     slashPruneEnabled: z.ZodBoolean;
     slashPrunePenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
     slashPruneMaxPenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
-    slashInvalidBlockEnabled: z.ZodBoolean;
-    slashInvalidBlockPenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
-    slashInvalidBlockMaxPenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+    slashBroadcastedInvalidBlockEnabled: z.ZodBoolean;
+    slashBroadcastedInvalidBlockPenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+    slashBroadcastedInvalidBlockMaxPenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
     slashInactivityEnabled: z.ZodBoolean;
     slashInactivityCreateTargetPercentage: z.ZodNumber;
     slashInactivitySignalTargetPercentage: z.ZodNumber;
@@ -41,15 +45,19 @@ export declare const SlasherConfigSchema: z.ZodObject<{
     slashProposeInvalidAttestationsMaxPenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
     slashAttestDescendantOfInvalidPenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
     slashAttestDescendantOfInvalidMaxPenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
-    slasherPrivateKey: z.ZodType<SecretValue<string | undefined>, any, any>;
+    slashUnknownPenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+    slashUnknownMaxPenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+    slashOffenseExpirationRounds: z.ZodNumber;
+    slashMaxPayloadSize: z.ZodNumber;
+    slashGracePeriodL2Slots: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {
     slashPayloadTtlSeconds: number;
     slashPruneEnabled: boolean;
     slashPrunePenalty: bigint;
     slashPruneMaxPenalty: bigint;
-    slashInvalidBlockEnabled: boolean;
-    slashInvalidBlockPenalty: bigint;
-    slashInvalidBlockMaxPenalty: bigint;
+    slashBroadcastedInvalidBlockEnabled: boolean;
+    slashBroadcastedInvalidBlockPenalty: bigint;
+    slashBroadcastedInvalidBlockMaxPenalty: bigint;
     slashInactivityEnabled: boolean;
     slashInactivityCreateTargetPercentage: number;
     slashInactivitySignalTargetPercentage: number;
@@ -60,16 +68,20 @@ export declare const SlasherConfigSchema: z.ZodObject<{
     slashProposeInvalidAttestationsMaxPenalty: bigint;
     slashAttestDescendantOfInvalidPenalty: bigint;
     slashAttestDescendantOfInvalidMaxPenalty: bigint;
-    slasherPrivateKey: SecretValue<string | undefined>;
+    slashUnknownPenalty: bigint;
+    slashUnknownMaxPenalty: bigint;
+    slashOffenseExpirationRounds: number;
+    slashMaxPayloadSize: number;
+    slashGracePeriodL2Slots: number;
     slashOverridePayload?: EthAddress | undefined;
 }, {
     slashPayloadTtlSeconds: number;
     slashPruneEnabled: boolean;
     slashPrunePenalty: string | number | bigint;
     slashPruneMaxPenalty: string | number | bigint;
-    slashInvalidBlockEnabled: boolean;
-    slashInvalidBlockPenalty: string | number | bigint;
-    slashInvalidBlockMaxPenalty: string | number | bigint;
+    slashBroadcastedInvalidBlockEnabled: boolean;
+    slashBroadcastedInvalidBlockPenalty: string | number | bigint;
+    slashBroadcastedInvalidBlockMaxPenalty: string | number | bigint;
     slashInactivityEnabled: boolean;
     slashInactivityCreateTargetPercentage: number;
     slashInactivitySignalTargetPercentage: number;
@@ -80,7 +92,11 @@ export declare const SlasherConfigSchema: z.ZodObject<{
     slashProposeInvalidAttestationsMaxPenalty: string | number | bigint;
     slashAttestDescendantOfInvalidPenalty: string | number | bigint;
     slashAttestDescendantOfInvalidMaxPenalty: string | number | bigint;
+    slashUnknownPenalty: string | number | bigint;
+    slashUnknownMaxPenalty: string | number | bigint;
+    slashOffenseExpirationRounds: number;
+    slashMaxPayloadSize: number;
+    slashGracePeriodL2Slots: number;
     slashOverridePayload?: string | undefined;
-    slasherPrivateKey?: any;
 }>;
 //# sourceMappingURL=slasher.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"slasher.d.ts","sourceRoot":"","sources":["../../src/interfaces/slasher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAGhE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,WAAW,aAAa;IAC5B,oBAAoB,CAAC,EAAE,UAAU,CAAC;IAClC,sBAAsB,EAAE,MAAM,CAAC;IAC/B,iBAAiB,EAAE,OAAO,CAAC;IAC3B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,oBAAoB,EAAE,MAAM,CAAC;IAC7B,wBAAwB,EAAE,OAAO,CAAC;IAClC,wBAAwB,EAAE,MAAM,CAAC;IACjC,2BAA2B,EAAE,MAAM,CAAC;IACpC,sBAAsB,EAAE,OAAO,CAAC;IAChC,qCAAqC,EAAE,MAAM,CAAC;IAC9C,qCAAqC,EAAE,MAAM,CAAC;IAC9C,4BAA4B,EAAE,MAAM,CAAC;IACrC,yBAAyB,EAAE,MAAM,CAAC;IAClC,wCAAwC,EAAE,MAAM,CAAC;IACjD,sCAAsC,EAAE,MAAM,CAAC;IAC/C,yCAAyC,EAAE,MAAM,CAAC;IAClD,qCAAqC,EAAE,MAAM,CAAC;IAC9C,wCAAwC,EAAE,MAAM,CAAC;IACjD,iBAAiB,EAAE,WAAW,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;CACpD;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoBE,CAAC"}
+{"version":3,"file":"slasher.d.ts","sourceRoot":"","sources":["../../src/interfaces/slasher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAGhE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,OAAO,CAAC;AAEnD,MAAM,WAAW,aAAa;IAC5B,oBAAoB,CAAC,EAAE,UAAU,CAAC;IAClC,sBAAsB,EAAE,MAAM,CAAC;IAC/B,iBAAiB,EAAE,OAAO,CAAC;IAC3B,iBAAiB,EAAE,MAAM,CAAC;IAC1B,oBAAoB,EAAE,MAAM,CAAC;IAC7B,mCAAmC,EAAE,OAAO,CAAC;IAC7C,mCAAmC,EAAE,MAAM,CAAC;IAC5C,sCAAsC,EAAE,MAAM,CAAC;IAC/C,sBAAsB,EAAE,OAAO,CAAC;IAChC,qCAAqC,EAAE,MAAM,CAAC;IAC9C,qCAAqC,EAAE,MAAM,CAAC;IAC9C,4BAA4B,EAAE,MAAM,CAAC;IACrC,yBAAyB,EAAE,MAAM,CAAC;IAClC,wCAAwC,EAAE,MAAM,CAAC;IACjD,sCAAsC,EAAE,MAAM,CAAC;IAC/C,yCAAyC,EAAE,MAAM,CAAC;IAClD,qCAAqC,EAAE,MAAM,CAAC;IAC9C,wCAAwC,EAAE,MAAM,CAAC;IACjD,mBAAmB,EAAE,MAAM,CAAC;IAC5B,sBAAsB,EAAE,MAAM,CAAC;IAC/B,4BAA4B,EAAE,MAAM,CAAC;IACrC,mBAAmB,EAAE,MAAM,CAAC;IAC5B,uBAAuB,EAAE,MAAM,CAAC;CACjC;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAwBE,CAAC"}

package/dest/interfaces/slasher.js

@@ -6,9 +6,9 @@ export const SlasherConfigSchema = z.object({
     slashPruneEnabled: z.boolean(),
     slashPrunePenalty: schemas.BigInt,
     slashPruneMaxPenalty: schemas.BigInt,
-    slashInvalidBlockEnabled: z.boolean(),
-    slashInvalidBlockPenalty: schemas.BigInt,
-    slashInvalidBlockMaxPenalty: schemas.BigInt,
+    slashBroadcastedInvalidBlockEnabled: z.boolean(),
+    slashBroadcastedInvalidBlockPenalty: schemas.BigInt,
+    slashBroadcastedInvalidBlockMaxPenalty: schemas.BigInt,
     slashInactivityEnabled: z.boolean(),
     slashInactivityCreateTargetPercentage: z.number(),
     slashInactivitySignalTargetPercentage: z.number(),
@@ -19,5 +19,9 @@ export const SlasherConfigSchema = z.object({
     slashProposeInvalidAttestationsMaxPenalty: schemas.BigInt,
     slashAttestDescendantOfInvalidPenalty: schemas.BigInt,
     slashAttestDescendantOfInvalidMaxPenalty: schemas.BigInt,
-    slasherPrivateKey: schemas.SecretValue(z.string().optional())
+    slashUnknownPenalty: schemas.BigInt,
+    slashUnknownMaxPenalty: schemas.BigInt,
+    slashOffenseExpirationRounds: z.number(),
+    slashMaxPayloadSize: z.number(),
+    slashGracePeriodL2Slots: z.number()
 });

package/dest/interfaces/world_state.d.ts

@@ -15,7 +15,7 @@ export declare enum WorldStateRunningState {
 export interface WorldStateSyncStatus {
     latestBlockNumber: number;
     latestBlockHash: string;
-    finalisedBlockNumber: number;
+    finalizedBlockNumber: number;
     oldestHistoricBlockNumber: number;
     treesAreSynched: boolean;
 }
@@ -66,19 +66,19 @@ export interface WorldStateSynchronizer extends ForkMerkleTreeOperations {
     clear(): Promise<void>;
 }
 export declare const WorldStateSyncStatusSchema: z.ZodObject<{
-    finalisedBlockNumber: z.ZodNumber;
+    finalizedBlockNumber: z.ZodNumber;
     latestBlockNumber: z.ZodNumber;
     latestBlockHash: z.ZodString;
     oldestHistoricBlockNumber: z.ZodNumber;
     treesAreSynched: z.ZodBoolean;
 }, "strip", z.ZodTypeAny, {
-    finalisedBlockNumber: number;
+    finalizedBlockNumber: number;
     latestBlockNumber: number;
     latestBlockHash: string;
     oldestHistoricBlockNumber: number;
     treesAreSynched: boolean;
 }, {
-    finalisedBlockNumber: number;
+    finalizedBlockNumber: number;
     latestBlockNumber: number;
     latestBlockHash: string;
     oldestHistoricBlockNumber: number;

package/dest/interfaces/world_state.js

@@ -9,7 +9,7 @@ import { z } from 'zod';
     return WorldStateRunningState;
 }({});
 export const WorldStateSyncStatusSchema = z.object({
-    finalisedBlockNumber: z.number().int().nonnegative(),
+    finalizedBlockNumber: z.number().int().nonnegative(),
     latestBlockNumber: z.number().int().nonnegative(),
     latestBlockHash: z.string(),
     oldestHistoricBlockNumber: z.number().int().nonnegative(),

package/dest/l1-contracts/index.d.ts

@@ -0,0 +1,2 @@
+export * from './slash_factory.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/l1-contracts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/l1-contracts/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/dest/l1-contracts/index.js

@@ -0,0 +1 @@
+export * from './slash_factory.js';

package/dest/l1-contracts/slash_factory.d.ts

@@ -0,0 +1,44 @@
+import { type L1TxRequest, type ViemClient } from '@aztec/ethereum';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { type Hex, type Log } from 'viem';
+import type { L1RollupConstants } from '../epoch-helpers/index.js';
+import { type SlashPayload, type ValidatorSlash, type ValidatorSlashOffense } from '../slashing/index.js';
+export declare class SlashFactoryContract {
+    readonly client: ViemClient;
+    private readonly logger;
+    private readonly contract;
+    constructor(client: ViemClient, address: Hex | EthAddress);
+    get address(): EthAddress;
+    buildCreatePayloadRequest(slashes: ValidatorSlash[]): L1TxRequest;
+    /** Tries to extract a SlashPayloadCreated event from the given logs. */
+    tryExtractSlashPayloadCreatedEvent(logs: Log[]): {
+        eventName: "SlashPayloadCreated";
+        args: {
+            payloadAddress: `0x${string}`;
+            validators: readonly `0x${string}`[];
+            amounts: readonly bigint[];
+            offenses: readonly (readonly bigint[])[];
+        };
+    } | undefined;
+    getSlashPayloadCreatedEvents(): Promise<SlashPayload[]>;
+    /**
+     * Searches for a slash payload in the events emitted by the contract.
+     * This method cannot query for historical payload events, it queries for payloads that have not yet expired.
+     * @param payloadAddress The address of the payload to search for.
+     * @param constants The L1 rollup constants needed for time calculations.
+     */
+    getSlashPayloadFromEvents(payloadAddress: EthAddress, settings: {
+        logsBatchSize?: number;
+        slashingRoundSize: number;
+        slashingPayloadLifetimeInRounds: number;
+    } & Pick<L1RollupConstants, 'slotDuration' | 'ethereumSlotDuration'>): Promise<Omit<SlashPayload, 'votes'> | undefined>;
+    getAddressAndIsDeployed(slashes: ValidatorSlash[]): Promise<{
+        address: EthAddress;
+        salt: Hex;
+        isDeployed: boolean;
+    }>;
+    private sortSlashes;
+}
+export declare function packValidatorSlashOffense(offense: ValidatorSlashOffense): bigint;
+export declare function unpackValidatorSlashOffense(packed: bigint): ValidatorSlashOffense;
+//# sourceMappingURL=slash_factory.d.ts.map

package/dest/l1-contracts/slash_factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slash_factory.d.ts","sourceRoot":"","sources":["../../src/l1-contracts/slash_factory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,WAAW,EAAE,KAAK,UAAU,EAAmB,MAAM,iBAAiB,CAAC;AAErF,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAI3D,OAAO,EAA8B,KAAK,GAAG,EAAE,KAAK,GAAG,EAAmC,MAAM,MAAM,CAAC;AAEvG,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AACnE,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,qBAAqB,EAE3B,MAAM,sBAAsB,CAAC;AAE9B,qBAAa,oBAAoB;aAKb,MAAM,EAAE,UAAU;IAJpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA2C;IAClE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA4D;gBAGnE,MAAM,EAAE,UAAU,EAClC,OAAO,EAAE,GAAG,GAAG,UAAU;IAS3B,IAAW,OAAO,eAEjB;IAEM,yBAAyB,CAAC,OAAO,EAAE,cAAc,EAAE,GAAG,WAAW;IAiBxE,wEAAwE;IACjE,kCAAkC,CAAC,IAAI,EAAE,GAAG,EAAE;;;;;;;;;IAIxC,4BAA4B,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;IAiBpE;;;;;OAKG;IACU,yBAAyB,CACpC,cAAc,EAAE,UAAU,EAC1B,QAAQ,EAAE;QACR,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,+BAA+B,EAAE,MAAM,CAAC;KACzC,GAAG,IAAI,CAAC,iBAAiB,EAAE,cAAc,GAAG,sBAAsB,CAAC,GACnE,OAAO,CAAC,IAAI,CAAC,YAAY,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;IAqDtC,uBAAuB,CAClC,OAAO,EAAE,cAAc,EAAE,GACxB,OAAO,CAAC;QAAE,OAAO,EAAE,UAAU,CAAC;QAAC,IAAI,EAAE,GAAG,CAAC;QAAC,UAAU,EAAE,OAAO,CAAA;KAAE,CAAC;IAUnE,OAAO,CAAC,WAAW;CAQpB;AAED,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,qBAAqB,GAAG,MAAM,CAMhF;AAED,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,MAAM,GAAG,qBAAqB,CAKjF"}

package/dest/l1-contracts/slash_factory.js

@@ -0,0 +1,157 @@
+import { tryExtractEvent } from '@aztec/ethereum';
+import { maxBigint } from '@aztec/foundation/bigint';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { createLogger } from '@aztec/foundation/log';
+import { SlashFactoryAbi } from '@aztec/l1-artifacts/SlashFactoryAbi';
+import { encodeFunctionData, getContract } from 'viem';
+import { OffenseToBigInt, bigIntToOffense } from '../slashing/index.js';
+export class SlashFactoryContract {
+    client;
+    logger;
+    contract;
+    constructor(client, address){
+        this.client = client;
+        this.logger = createLogger('contracts:slash_factory');
+        this.contract = getContract({
+            address: typeof address === 'string' ? address : address.toString(),
+            abi: SlashFactoryAbi,
+            client
+        });
+    }
+    get address() {
+        return EthAddress.fromString(this.contract.address);
+    }
+    buildCreatePayloadRequest(slashes) {
+        const sorted = this.sortSlashes(slashes);
+        return {
+            to: this.contract.address,
+            data: encodeFunctionData({
+                abi: SlashFactoryAbi,
+                functionName: 'createSlashPayload',
+                args: [
+                    sorted.map((d)=>d.validator.toString()),
+                    sorted.map((d)=>d.amount),
+                    sorted.map((d)=>d.offenses.map(packValidatorSlashOffense))
+                ]
+            })
+        };
+    }
+    /** Tries to extract a SlashPayloadCreated event from the given logs. */ tryExtractSlashPayloadCreatedEvent(logs) {
+        return tryExtractEvent(logs, this.address.toString(), SlashFactoryAbi, 'SlashPayloadCreated');
+    }
+    async getSlashPayloadCreatedEvents() {
+        const events = await this.contract.getEvents.SlashPayloadCreated();
+        return Promise.all(events.map(async (event)=>{
+            const { validators, amounts, offenses } = event.args;
+            const slashes = validators.map((validator, i)=>({
+                    validator: EthAddress.fromString(validator),
+                    amount: amounts[i],
+                    offenses: offenses[i].map(unpackValidatorSlashOffense)
+                }));
+            const block = await this.client.getBlock({
+                blockNumber: event.blockNumber,
+                includeTransactions: false
+            });
+            return {
+                address: EthAddress.fromString(event.args.payloadAddress),
+                slashes,
+                timestamp: block.timestamp
+            };
+        }));
+    }
+    /**
+   * Searches for a slash payload in the events emitted by the contract.
+   * This method cannot query for historical payload events, it queries for payloads that have not yet expired.
+   * @param payloadAddress The address of the payload to search for.
+   * @param constants The L1 rollup constants needed for time calculations.
+   */ async getSlashPayloadFromEvents(payloadAddress, settings) {
+        // We query for the log where the payload was emitted walking backwards until we go past payload expiration time
+        // Note that all log queries require a block range, and RPC providers cap the max range (eg quicknode is 10k blocks).
+        const { slashingRoundSize, slashingPayloadLifetimeInRounds, slotDuration, ethereumSlotDuration } = settings;
+        const currentBlockNumber = await this.client.getBlockNumber({
+            cacheTime: 0
+        });
+        // Why the +1 below? Just for good measure. Better err on the safe side.
+        const earliestBlockNumber = maxBigint(0n, currentBlockNumber - (BigInt(slashingPayloadLifetimeInRounds) + 1n) * BigInt(slashingRoundSize) * BigInt(slotDuration) / BigInt(ethereumSlotDuration));
+        this.logger.trace(`Starting search for slash payload ${payloadAddress} from block ${currentBlockNumber} with earliest block ${earliestBlockNumber}`);
+        const batchSize = BigInt(settings.logsBatchSize ?? 10000);
+        let toBlock = currentBlockNumber;
+        do {
+            const fromBlock = maxBigint(earliestBlockNumber, toBlock - batchSize);
+            this.logger.trace(`Searching for slash payload ${payloadAddress} in blocks ${fromBlock} to ${toBlock}`);
+            const logs = await this.contract.getEvents.SlashPayloadCreated({
+                payloadAddress: payloadAddress.toString()
+            }, {
+                fromBlock,
+                toBlock,
+                strict: true
+            });
+            // We found the payload, return it
+            if (logs.length > 0) {
+                const log = logs[0];
+                const { validators, amounts, offenses } = log.args;
+                // Convert the data to our internal types
+                const slashes = validators.map((validator, i)=>({
+                        validator: EthAddress.fromString(validator),
+                        amount: amounts[i],
+                        offenses: offenses[i].map(unpackValidatorSlashOffense)
+                    }));
+                // Get the timestamp from the block
+                const block = await this.client.getBlock({
+                    blockNumber: log.blockNumber,
+                    includeTransactions: false
+                });
+                return {
+                    address: payloadAddress,
+                    slashes,
+                    timestamp: block.timestamp
+                };
+            }
+            // If not found, we go back one batch
+            toBlock -= batchSize;
+        }while (toBlock > earliestBlockNumber)
+        return undefined;
+    }
+    async getAddressAndIsDeployed(slashes) {
+        const sortedSlashes = this.sortSlashes(slashes);
+        const [address, salt, isDeployed] = await this.contract.read.getAddressAndIsDeployed([
+            sortedSlashes.map((s)=>s.validator.toString()),
+            sortedSlashes.map((s)=>s.amount),
+            sortedSlashes.map((s)=>s.offenses.map(packValidatorSlashOffense))
+        ]);
+        return {
+            address: EthAddress.fromString(address),
+            salt,
+            isDeployed
+        };
+    }
+    sortSlashes(slashes) {
+        const offenseSorter = (a, b)=>{
+            return a.epochOrSlot === b.epochOrSlot ? a.offenseType - b.offenseType : Number(a.epochOrSlot - b.epochOrSlot);
+        };
+        return [
+            ...slashes
+        ].map((slash)=>({
+                ...slash,
+                offenses: [
+                    ...slash.offenses
+                ].sort(offenseSorter)
+            })).sort((a, b)=>a.validator.toString().localeCompare(b.validator.toString()));
+    }
+}
+export function packValidatorSlashOffense(offense) {
+    const offenseId = OffenseToBigInt[offense.offenseType];
+    if (offenseId > (1 << 8) - 1) {
+        throw new Error(`Offense type ${offense.offenseType} cannot be packed into 8 bits`);
+    }
+    return (offenseId << 120n) + offense.epochOrSlot;
+}
+export function unpackValidatorSlashOffense(packed) {
+    const offenseId = packed >> 120n & 0xffn;
+    const epochOrSlot = packed & (1n << 120n) - 1n;
+    const offenseType = bigIntToOffense(offenseId);
+    return {
+        epochOrSlot,
+        offenseType
+    };
+}

package/dest/slashing/empire.d.ts

@@ -0,0 +1,31 @@
+import type { Offense, OffenseIdentifier, SlashPayload, SlashPayloadRound, ValidatorSlash } from './types.js';
+import { OffenseType } from './types.js';
+/**
+ * Returns true if the offense is uncontroversial as in it can be verified via L1 data alone,
+ * and does not depend on the local view of the node of the L2 p2p network.
+ * @param offense - The offense type to check
+ */
+export declare function isOffenseUncontroversial(offense: OffenseType): boolean;
+/** Extracts offense identifiers (validator, epoch, offense type) from an Empire-based SlashPayload */
+export declare function getOffenseIdentifiersFromPayload(payload: SlashPayload | SlashPayloadRound): OffenseIdentifier[];
+/** Creates ValidatorSlashes used to create an Empire-based SlashPayload from a set of Offenses */
+export declare function offensesToValidatorSlash(offenses: Offense[]): ValidatorSlash[];
+/**
+ * Sorts offense data by:
+ * - Uncontroversial offenses first
+ * - Slash amount (descending)
+ * - Epoch or slot (ascending, ie oldest first)
+ * - Validator address (ascending)
+ * - Offense type (descending)
+ */
+export declare function offenseDataComparator(a: Offense, b: Offense): number;
+/**
+ * Returns the first round in which the offense is eligible for being included in an Empire-based slash payload.
+ * Should be equal to to the first round that starts strictly after the offense becomes detectable.
+ */
+export declare function getFirstEligibleRoundForOffense(offense: OffenseIdentifier, constants: {
+    slashingRoundSize: number;
+    epochDuration: number;
+    proofSubmissionEpochs: number;
+}): bigint;
+//# sourceMappingURL=empire.d.ts.map

package/dest/slashing/empire.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"empire.d.ts","sourceRoot":"","sources":["../../src/slashing/empire.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,iBAAiB,EAAE,YAAY,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC9G,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEzC;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAMtE;AAED,sGAAsG;AACtG,wBAAgB,gCAAgC,CAAC,OAAO,EAAE,YAAY,GAAG,iBAAiB,GAAG,iBAAiB,EAAE,CAQ/G;AAED,kGAAkG;AAClG,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,cAAc,EAAE,CAM9E;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,MAAM,CAQpE;AAED;;;GAGG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,iBAAiB,EAC1B,SAAS,EAAE;IAAE,iBAAiB,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,qBAAqB,EAAE,MAAM,CAAA;CAAE,GAC7F,MAAM,CAqCR"}