@aztec/stdlib 2.0.0-nightly.20250828 → 2.0.0-nightly.20250830

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

@@ -103,58 +103,45 @@ export declare const AztecNodeAdminConfigSchema: z.ZodObject<z.objectUtil.extend
     proverAgentCount: z.ZodNumber;
 }>, {
     slashOverridePayload: z.ZodOptional<z.ZodType<import("@aztec/foundation/schemas").EthAddress, any, string>>;
-    slashPayloadTtlSeconds: z.ZodNumber;
-    slashPruneEnabled: z.ZodBoolean;
+    slashMinPenaltyPercentage: z.ZodNumber;
+    slashMaxPenaltyPercentage: z.ZodNumber;
+    slashValidatorsAlways: z.ZodArray<z.ZodType<import("@aztec/foundation/schemas").EthAddress, any, string>, "many">;
+    slashValidatorsNever: z.ZodArray<z.ZodType<import("@aztec/foundation/schemas").EthAddress, any, string>, "many">;
     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>;
-    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;
-    slashInactivityCreatePenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
-    slashInactivityMaxPenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+    slashInactivityTargetPercentage: z.ZodNumber;
+    slashInactivityPenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
     slashProposeInvalidAttestationsPenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
-    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>;
     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;
+    slashBroadcastedInvalidBlockPenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+    slashSelfAllowed: z.ZodOptional<z.ZodBoolean>;
 }>, {
     maxTxPoolSize: z.ZodNumber;
 }>, "strip", z.ZodTypeAny, {
     secondsBeforeInvalidatingBlockAsCommitteeMember: number;
     secondsBeforeInvalidatingBlockAsNonCommitteeMember: number;
-    realProofs: boolean;
-    proverTestDelayType: "fixed" | "realistic";
-    proverTestDelayMs: number;
-    proverTestDelayFactor: number;
-    proverAgentCount: number;
-    slashPayloadTtlSeconds: number;
-    slashPruneEnabled: boolean;
+    slashMinPenaltyPercentage: number;
+    slashMaxPenaltyPercentage: number;
+    slashValidatorsAlways: import("@aztec/foundation/schemas").EthAddress[];
+    slashValidatorsNever: import("@aztec/foundation/schemas").EthAddress[];
     slashPrunePenalty: bigint;
-    slashPruneMaxPenalty: bigint;
-    slashBroadcastedInvalidBlockEnabled: boolean;
-    slashBroadcastedInvalidBlockPenalty: bigint;
-    slashBroadcastedInvalidBlockMaxPenalty: bigint;
-    slashInactivityEnabled: boolean;
-    slashInactivityCreateTargetPercentage: number;
-    slashInactivitySignalTargetPercentage: number;
-    slashInactivityCreatePenalty: bigint;
-    slashInactivityMaxPenalty: bigint;
+    slashInactivityTargetPercentage: number;
+    slashInactivityPenalty: bigint;
     slashProposeInvalidAttestationsPenalty: bigint;
-    slashProposeInvalidAttestationsMaxPenalty: bigint;
     slashAttestDescendantOfInvalidPenalty: bigint;
-    slashAttestDescendantOfInvalidMaxPenalty: bigint;
     slashUnknownPenalty: bigint;
-    slashUnknownMaxPenalty: bigint;
     slashOffenseExpirationRounds: number;
     slashMaxPayloadSize: number;
     slashGracePeriodL2Slots: number;
+    slashBroadcastedInvalidBlockPenalty: bigint;
+    realProofs: boolean;
+    proverTestDelayType: "fixed" | "realistic";
+    proverTestDelayMs: number;
+    proverTestDelayFactor: number;
+    proverAgentCount: number;
     maxTxPoolSize: number;
     coinbase?: import("@aztec/foundation/schemas").EthAddress | undefined;
     feeRecipient?: import("../aztec-address/index.js").AztecAddress | undefined;
@@ -185,37 +172,31 @@ export declare const AztecNodeAdminConfigSchema: z.ZodObject<z.objectUtil.extend
     attestationPropagationTime?: number | undefined;
     skipCollectingAttestations?: boolean | undefined;
     proverId?: import("@aztec/foundation/schemas").EthAddress | undefined;
-    nodeUrl?: string | undefined;
     slashOverridePayload?: import("@aztec/foundation/schemas").EthAddress | undefined;
+    slashSelfAllowed?: boolean | undefined;
+    nodeUrl?: string | undefined;
 }, {
     secondsBeforeInvalidatingBlockAsCommitteeMember: number;
     secondsBeforeInvalidatingBlockAsNonCommitteeMember: number;
-    realProofs: boolean;
-    proverTestDelayType: "fixed" | "realistic";
-    proverTestDelayMs: number;
-    proverTestDelayFactor: number;
-    proverAgentCount: number;
-    slashPayloadTtlSeconds: number;
-    slashPruneEnabled: boolean;
+    slashMinPenaltyPercentage: number;
+    slashMaxPenaltyPercentage: number;
+    slashValidatorsAlways: string[];
+    slashValidatorsNever: string[];
     slashPrunePenalty: string | number | bigint;
-    slashPruneMaxPenalty: string | number | bigint;
-    slashBroadcastedInvalidBlockEnabled: boolean;
-    slashBroadcastedInvalidBlockPenalty: string | number | bigint;
-    slashBroadcastedInvalidBlockMaxPenalty: string | number | bigint;
-    slashInactivityEnabled: boolean;
-    slashInactivityCreateTargetPercentage: number;
-    slashInactivitySignalTargetPercentage: number;
-    slashInactivityCreatePenalty: string | number | bigint;
-    slashInactivityMaxPenalty: string | number | bigint;
+    slashInactivityTargetPercentage: number;
+    slashInactivityPenalty: string | number | bigint;
     slashProposeInvalidAttestationsPenalty: string | number | bigint;
-    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;
+    slashBroadcastedInvalidBlockPenalty: string | number | bigint;
+    realProofs: boolean;
+    proverTestDelayType: "fixed" | "realistic";
+    proverTestDelayMs: number;
+    proverTestDelayFactor: number;
+    proverAgentCount: number;
     maxTxPoolSize: number;
     coinbase?: any;
     feeRecipient?: any;
@@ -246,8 +227,9 @@ export declare const AztecNodeAdminConfigSchema: z.ZodObject<z.objectUtil.extend
     attestationPropagationTime?: number | undefined;
     skipCollectingAttestations?: boolean | undefined;
     proverId?: any;
-    nodeUrl?: string | undefined;
     slashOverridePayload?: string | undefined;
+    slashSelfAllowed?: boolean | undefined;
+    nodeUrl?: string | undefined;
 }>;
 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,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"}
+{"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/slasher.d.ts

@@ -3,96 +3,72 @@ import { z } from 'zod';
 export type SlasherClientType = 'empire' | 'tally';
 export interface SlasherConfig {
     slashOverridePayload?: EthAddress;
-    slashPayloadTtlSeconds: number;
-    slashPruneEnabled: boolean;
+    slashMinPenaltyPercentage: number;
+    slashMaxPenaltyPercentage: number;
+    slashSelfAllowed?: boolean;
+    slashValidatorsAlways: EthAddress[];
+    slashValidatorsNever: EthAddress[];
+    slashInactivityTargetPercentage: number;
     slashPrunePenalty: bigint;
-    slashPruneMaxPenalty: bigint;
-    slashBroadcastedInvalidBlockEnabled: boolean;
+    slashInactivityPenalty: bigint;
     slashBroadcastedInvalidBlockPenalty: bigint;
-    slashBroadcastedInvalidBlockMaxPenalty: bigint;
-    slashInactivityEnabled: boolean;
-    slashInactivityCreateTargetPercentage: number;
-    slashInactivitySignalTargetPercentage: number;
-    slashInactivityCreatePenalty: bigint;
-    slashInactivityMaxPenalty: bigint;
     slashProposeInvalidAttestationsPenalty: bigint;
-    slashProposeInvalidAttestationsMaxPenalty: bigint;
     slashAttestDescendantOfInvalidPenalty: bigint;
-    slashAttestDescendantOfInvalidMaxPenalty: bigint;
     slashUnknownPenalty: bigint;
-    slashUnknownMaxPenalty: bigint;
     slashOffenseExpirationRounds: number;
     slashMaxPayloadSize: number;
     slashGracePeriodL2Slots: number;
 }
 export declare const SlasherConfigSchema: z.ZodObject<{
     slashOverridePayload: z.ZodOptional<z.ZodType<EthAddress, any, string>>;
-    slashPayloadTtlSeconds: z.ZodNumber;
-    slashPruneEnabled: z.ZodBoolean;
+    slashMinPenaltyPercentage: z.ZodNumber;
+    slashMaxPenaltyPercentage: z.ZodNumber;
+    slashValidatorsAlways: z.ZodArray<z.ZodType<EthAddress, any, string>, "many">;
+    slashValidatorsNever: z.ZodArray<z.ZodType<EthAddress, any, string>, "many">;
     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>;
-    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;
-    slashInactivityCreatePenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
-    slashInactivityMaxPenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+    slashInactivityTargetPercentage: z.ZodNumber;
+    slashInactivityPenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
     slashProposeInvalidAttestationsPenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
-    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>;
     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;
+    slashBroadcastedInvalidBlockPenalty: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+    slashSelfAllowed: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
-    slashPayloadTtlSeconds: number;
-    slashPruneEnabled: boolean;
+    slashMinPenaltyPercentage: number;
+    slashMaxPenaltyPercentage: number;
+    slashValidatorsAlways: EthAddress[];
+    slashValidatorsNever: EthAddress[];
     slashPrunePenalty: bigint;
-    slashPruneMaxPenalty: bigint;
-    slashBroadcastedInvalidBlockEnabled: boolean;
-    slashBroadcastedInvalidBlockPenalty: bigint;
-    slashBroadcastedInvalidBlockMaxPenalty: bigint;
-    slashInactivityEnabled: boolean;
-    slashInactivityCreateTargetPercentage: number;
-    slashInactivitySignalTargetPercentage: number;
-    slashInactivityCreatePenalty: bigint;
-    slashInactivityMaxPenalty: bigint;
+    slashInactivityTargetPercentage: number;
+    slashInactivityPenalty: bigint;
     slashProposeInvalidAttestationsPenalty: bigint;
-    slashProposeInvalidAttestationsMaxPenalty: bigint;
     slashAttestDescendantOfInvalidPenalty: bigint;
-    slashAttestDescendantOfInvalidMaxPenalty: bigint;
     slashUnknownPenalty: bigint;
-    slashUnknownMaxPenalty: bigint;
     slashOffenseExpirationRounds: number;
     slashMaxPayloadSize: number;
     slashGracePeriodL2Slots: number;
+    slashBroadcastedInvalidBlockPenalty: bigint;
     slashOverridePayload?: EthAddress | undefined;
+    slashSelfAllowed?: boolean | undefined;
 }, {
-    slashPayloadTtlSeconds: number;
-    slashPruneEnabled: boolean;
+    slashMinPenaltyPercentage: number;
+    slashMaxPenaltyPercentage: number;
+    slashValidatorsAlways: string[];
+    slashValidatorsNever: string[];
     slashPrunePenalty: string | number | bigint;
-    slashPruneMaxPenalty: string | number | bigint;
-    slashBroadcastedInvalidBlockEnabled: boolean;
-    slashBroadcastedInvalidBlockPenalty: string | number | bigint;
-    slashBroadcastedInvalidBlockMaxPenalty: string | number | bigint;
-    slashInactivityEnabled: boolean;
-    slashInactivityCreateTargetPercentage: number;
-    slashInactivitySignalTargetPercentage: number;
-    slashInactivityCreatePenalty: string | number | bigint;
-    slashInactivityMaxPenalty: string | number | bigint;
+    slashInactivityTargetPercentage: number;
+    slashInactivityPenalty: string | number | bigint;
     slashProposeInvalidAttestationsPenalty: string | number | bigint;
-    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;
+    slashBroadcastedInvalidBlockPenalty: string | number | bigint;
     slashOverridePayload?: string | undefined;
+    slashSelfAllowed?: boolean | undefined;
 }>;
 //# 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,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,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuBE,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,yBAAyB,EAAE,MAAM,CAAC;IAClC,yBAAyB,EAAE,MAAM,CAAC;IAClC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,qBAAqB,EAAE,UAAU,EAAE,CAAC;IACpC,oBAAoB,EAAE,UAAU,EAAE,CAAC;IACnC,+BAA+B,EAAE,MAAM,CAAC;IACxC,iBAAiB,EAAE,MAAM,CAAC;IAC1B,sBAAsB,EAAE,MAAM,CAAC;IAC/B,mCAAmC,EAAE,MAAM,CAAC;IAC5C,sCAAsC,EAAE,MAAM,CAAC;IAC/C,qCAAqC,EAAE,MAAM,CAAC;IAC9C,mBAAmB,EAAE,MAAM,CAAC;IAC5B,4BAA4B,EAAE,MAAM,CAAC;IACrC,mBAAmB,EAAE,MAAM,CAAC;IAC5B,uBAAuB,EAAE,MAAM,CAAC;CACjC;AAED,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiBE,CAAC"}

package/dest/interfaces/slasher.js

@@ -2,25 +2,19 @@ import { schemas } from '@aztec/foundation/schemas';
 import { z } from 'zod';
 export const SlasherConfigSchema = z.object({
     slashOverridePayload: schemas.EthAddress.optional(),
-    slashPayloadTtlSeconds: z.number(),
-    slashPruneEnabled: z.boolean(),
+    slashMinPenaltyPercentage: z.number(),
+    slashMaxPenaltyPercentage: z.number(),
+    slashValidatorsAlways: z.array(schemas.EthAddress),
+    slashValidatorsNever: z.array(schemas.EthAddress),
     slashPrunePenalty: schemas.BigInt,
-    slashPruneMaxPenalty: schemas.BigInt,
-    slashBroadcastedInvalidBlockEnabled: z.boolean(),
-    slashBroadcastedInvalidBlockPenalty: schemas.BigInt,
-    slashBroadcastedInvalidBlockMaxPenalty: schemas.BigInt,
-    slashInactivityEnabled: z.boolean(),
-    slashInactivityCreateTargetPercentage: z.number(),
-    slashInactivitySignalTargetPercentage: z.number(),
-    slashInactivityCreatePenalty: schemas.BigInt,
-    slashInactivityMaxPenalty: schemas.BigInt,
+    slashInactivityTargetPercentage: z.number(),
+    slashInactivityPenalty: schemas.BigInt,
     slashProposeInvalidAttestationsPenalty: schemas.BigInt,
-    slashProposeInvalidAttestationsMaxPenalty: schemas.BigInt,
     slashAttestDescendantOfInvalidPenalty: schemas.BigInt,
-    slashAttestDescendantOfInvalidMaxPenalty: schemas.BigInt,
     slashUnknownPenalty: schemas.BigInt,
-    slashUnknownMaxPenalty: schemas.BigInt,
     slashOffenseExpirationRounds: z.number(),
     slashMaxPayloadSize: z.number(),
-    slashGracePeriodL2Slots: z.number()
+    slashGracePeriodL2Slots: z.number(),
+    slashBroadcastedInvalidBlockPenalty: schemas.BigInt,
+    slashSelfAllowed: z.boolean().optional()
 });

package/dest/slashing/helpers.d.ts

@@ -1,4 +1,5 @@
 import { type L1RollupConstants } from '../epoch-helpers/index.js';
+import type { SlasherConfig } from '../interfaces/slasher.js';
 import { type Offense, OffenseType } from './types.js';
 /** Returns the voting round number and voting slot within the round for a given L2 slot. */
 export declare function getRoundForSlot(slot: bigint, constants: {
@@ -17,6 +18,8 @@ export declare function getEpochsForRound(round: bigint, constants: {
     slashingRoundSize: number;
     epochDuration: number;
 }): bigint[];
+/** Reads the configured penalty for a given offense type from a slasher config struct */
+export declare function getPenaltyForOffense(offense: OffenseType, config: Pick<SlasherConfig, 'slashAttestDescendantOfInvalidPenalty' | 'slashBroadcastedInvalidBlockPenalty' | 'slashPrunePenalty' | 'slashUnknownPenalty' | 'slashInactivityPenalty' | 'slashProposeInvalidAttestationsPenalty'>): bigint;
 /** Returns whether the `epochOrSlot` field for an offense references an epoch or a slot */
 export declare function getTimeUnitForOffense(offense: OffenseType): 'epoch' | 'slot';
 /** Returns the slot for a given offense. If the offense references an epoch, returns the first slot of the epoch. */

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

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/slashing/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,iBAAiB,EAAwC,MAAM,2BAA2B,CAAC;AACzG,OAAO,EAAE,KAAK,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEvD,4FAA4F;AAC5F,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE;IAAE,iBAAiB,EAAE,MAAM,CAAA;CAAE,GACvC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAKvC;AAED,gGAAgG;AAChG,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,EACb,SAAS,EAAE;IAAE,iBAAiB,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,GAC9D,CAAC,MAAM,EAAE,MAAM,CAAC,CAKlB;AAED,+DAA+D;AAC/D,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,EACb,SAAS,EAAE;IAAE,iBAAiB,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,GAC9D,MAAM,EAAE,CAUV;AAED,2FAA2F;AAC3F,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,GAAG,MAAM,CAiB5E;AAED,qHAAqH;AACrH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,aAAa,GAAG,aAAa,CAAC,EACrD,SAAS,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,GAClD,MAAM,CAGR;AAED,6CAA6C;AAC7C,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,aAAa,GAAG,aAAa,CAAC,EACrD,SAAS,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,GAClD,MAAM,CAGR;AAED,oEAAoE;AACpE,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,aAAa,GAAG,aAAa,CAAC,EACrD,SAAS,EAAE;IAAE,iBAAiB,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,GAC9D,MAAM,CAGR"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/slashing/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,iBAAiB,EAAwC,MAAM,2BAA2B,CAAC;AACzG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAC9D,OAAO,EAAE,KAAK,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAEvD,4FAA4F;AAC5F,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE;IAAE,iBAAiB,EAAE,MAAM,CAAA;CAAE,GACvC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAKvC;AAED,gGAAgG;AAChG,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,EACb,SAAS,EAAE;IAAE,iBAAiB,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,GAC9D,CAAC,MAAM,EAAE,MAAM,CAAC,CAKlB;AAED,+DAA+D;AAC/D,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,EACb,SAAS,EAAE;IAAE,iBAAiB,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,GAC9D,MAAM,EAAE,CAUV;AAED,yFAAyF;AACzF,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,WAAW,EACpB,MAAM,EAAE,IAAI,CACV,aAAa,EACX,uCAAuC,GACvC,qCAAqC,GACrC,mBAAmB,GACnB,qBAAqB,GACrB,wBAAwB,GACxB,wCAAwC,CAC3C,UAsBF;AAED,2FAA2F;AAC3F,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,GAAG,MAAM,CAiB5E;AAED,qHAAqH;AACrH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,aAAa,GAAG,aAAa,CAAC,EACrD,SAAS,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,GAClD,MAAM,CAGR;AAED,6CAA6C;AAC7C,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,aAAa,GAAG,aAAa,CAAC,EACrD,SAAS,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,GAClD,MAAM,CAGR;AAED,oEAAoE;AACpE,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,aAAa,GAAG,aAAa,CAAC,EACrD,SAAS,EAAE;IAAE,iBAAiB,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,GAC9D,MAAM,CAGR"}

package/dest/slashing/helpers.js

@@ -29,6 +29,29 @@ import { OffenseType } from './types.js';
     }
     return epochs;
 }
+/** Reads the configured penalty for a given offense type from a slasher config struct */ export function getPenaltyForOffense(offense, config) {
+    switch(offense){
+        case OffenseType.VALID_EPOCH_PRUNED:
+        case OffenseType.DATA_WITHHOLDING:
+            return config.slashPrunePenalty;
+        case OffenseType.INACTIVITY:
+            return config.slashInactivityPenalty;
+        case OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS:
+        case OffenseType.PROPOSED_INCORRECT_ATTESTATIONS:
+            return config.slashProposeInvalidAttestationsPenalty;
+        case OffenseType.ATTESTED_DESCENDANT_OF_INVALID:
+            return config.slashAttestDescendantOfInvalidPenalty;
+        case OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL:
+            return config.slashBroadcastedInvalidBlockPenalty;
+        case OffenseType.UNKNOWN:
+            return config.slashUnknownPenalty;
+        default:
+            {
+                const _ = offense;
+                throw new Error(`Unknown offense type: ${offense}`);
+            }
+    }
+}
 /** Returns whether the `epochOrSlot` field for an offense references an epoch or a slot */ export function getTimeUnitForOffense(offense) {
     switch(offense){
         case OffenseType.ATTESTED_DESCENDANT_OF_INVALID:

package/dest/slashing/tally.d.ts

@@ -1,11 +1,14 @@
-import type { EthAddress } from '@aztec/foundation/eth-address';
+import { EthAddress } from '@aztec/foundation/eth-address';
 import type { Offense, ValidatorSlashVote } from './types.js';
 /**
  * Creates a consensus-slash vote for a given set of committees based on a set of Offenses
+ * @param offenses - Array of offenses to consider
+ * @param committees - Array of committees (each containing array of validator addresses)
+ * @param settings - Settings including slashingAmounts and optional validator override lists
  * @returns Array of ValidatorSlashVote, where each vote is how many slash units the validator in that position should be slashed
  */
-export declare function getSlashConsensusVotesFromOffenses(offenses: Offense[], committees: EthAddress[][], settings: {
-    slashingUnit: bigint;
+export declare function getSlashConsensusVotesFromOffenses(offenses: Pick<Offense, 'validator' | 'amount'>[], committees: EthAddress[][], settings: {
+    slashingAmounts: [bigint, bigint, bigint];
 }): ValidatorSlashVote[];
 /**
  * Encodes a set of slash votes into a Buffer for use in a consensus slashing vote transaction.

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

@@ -1 +1 @@
-{"version":3,"file":"tally.d.ts","sourceRoot":"","sources":["../../src/slashing/tally.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAEhE,OAAO,KAAK,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAK9D;;;GAGG;AACH,wBAAgB,kCAAkC,CAChD,QAAQ,EAAE,OAAO,EAAE,EACnB,UAAU,EAAE,UAAU,EAAE,EAAE,EAC1B,QAAQ,EAAE;IAAE,YAAY,EAAE,MAAM,CAAA;CAAE,GACjC,kBAAkB,EAAE,CAgBtB;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,kBAAkB,EAAE,GAAG,MAAM,CAe7E"}
+{"version":3,"file":"tally.d.ts","sourceRoot":"","sources":["../../src/slashing/tally.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAE3D,OAAO,KAAK,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAE9D;;;;;;GAMG;AACH,wBAAgB,kCAAkC,CAChD,QAAQ,EAAE,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,QAAQ,CAAC,EAAE,EACjD,UAAU,EAAE,UAAU,EAAE,EAAE,EAC1B,QAAQ,EAAE;IACR,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;CAC3C,GACA,kBAAkB,EAAE,CAuBtB;AAeD;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,kBAAkB,EAAE,GAAG,MAAM,CAe7E"}

package/dest/slashing/tally.js

@@ -1,23 +1,39 @@
-import { minBigint, sumBigint } from '@aztec/foundation/bigint';
-/** How many slashing units a validator can be slashed in consensus-based slashing */ const MAX_SLASH_UNITS_PER_VALIDATOR = 3n;
+import { sumBigint } from '@aztec/foundation/bigint';
 /**
  * Creates a consensus-slash vote for a given set of committees based on a set of Offenses
+ * @param offenses - Array of offenses to consider
+ * @param committees - Array of committees (each containing array of validator addresses)
+ * @param settings - Settings including slashingAmounts and optional validator override lists
  * @returns Array of ValidatorSlashVote, where each vote is how many slash units the validator in that position should be slashed
  */ export function getSlashConsensusVotesFromOffenses(offenses, committees, settings) {
-    const { slashingUnit } = settings;
-    const slashed = new Set();
+    const { slashingAmounts } = settings;
+    const slashedSet = new Set();
     const votes = committees.flatMap((committee)=>committee.map((validator)=>{
-            if (slashed.has(validator.toString())) {
-                return 0; // Already voted for slashing this validator
+            const validatorStr = validator.toString();
+            // If already voted for slashing this validator, skip
+            if (slashedSet.has(validatorStr)) {
+                return 0;
             }
+            // Normal offense-based slashing logic
             const validatorOffenses = offenses.filter((o)=>o.validator.equals(validator));
             const slashAmount = sumBigint(validatorOffenses.map((o)=>o.amount));
-            const slashUnits = minBigint(slashAmount / slashingUnit, MAX_SLASH_UNITS_PER_VALIDATOR);
-            slashed.add(validator.toString());
+            const slashUnits = getSlashUnitsForAmount(slashAmount, slashingAmounts);
+            slashedSet.add(validatorStr);
             return Number(slashUnits);
         }));
     return votes;
 }
+/** Returns the slash vote for the given amount to slash. */ function getSlashUnitsForAmount(amountToSlash, slashingAmounts) {
+    if (amountToSlash >= slashingAmounts[2]) {
+        return 3;
+    } else if (amountToSlash >= slashingAmounts[1]) {
+        return 2;
+    } else if (amountToSlash >= slashingAmounts[0]) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
 /**
  * Encodes a set of slash votes into a Buffer for use in a consensus slashing vote transaction.
  * Each vote is represented as a 2-bit value, which represents how many slashing units the validator should be slashed.

package/dest/vks/verification_key.d.ts

@@ -58,7 +58,6 @@ export declare class CommitmentMap {
 }
 export declare const CIRCUIT_SIZE_INDEX = 0;
 export declare const CIRCUIT_PUBLIC_INPUTS_INDEX = 1;
-export declare const CIRCUIT_RECURSIVE_INDEX = 3;
 /**
  * Provides a 'fields' representation of a circuit's verification key
  */
@@ -69,7 +68,6 @@ export declare class VerificationKeyAsFields {
     static fromKey(key: Fr[]): Promise<VerificationKeyAsFields>;
     get numPublicInputs(): number;
     get circuitSize(): number;
-    get isRecursive(): boolean;
     static get schema(): import("zod").ZodType<VerificationKeyAsFields, any, string>;
     toJSON(): Buffer<ArrayBufferLike>;
     /**
@@ -174,7 +172,6 @@ export declare class VerificationKeyData {
     constructor(keyAsFields: VerificationKeyAsFields, keyAsBytes: Buffer);
     get numPublicInputs(): number;
     get circuitSize(): number;
-    get isRecursive(): boolean;
     static empty(): VerificationKeyData;
     static makeFakeHonk(): VerificationKeyData;
     static makeFakeRollupHonk(): VerificationKeyData;

package/dest/vks/verification_key.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"verification_key.d.ts","sourceRoot":"","sources":["../../src/vks/verification_key.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"verification_key.d.ts","sourceRoot":"","sources":["../../src/vks/verification_key.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,EAAE,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAElD,OAAO,EAAE,YAAY,EAAqB,MAAM,6BAA6B,CAAC;AAI9E,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD;;GAEG;AACH,qBAAa,eAAe;IAC1B;;OAEG;IACI,CAAC,EAAE,EAAE,CAAC;IACb;;OAEG;IACI,CAAC,EAAE,EAAE,CAAC;gBAED,CAAC,EAAE,EAAE,GAAG,MAAM,EAAE,CAAC,EAAE,EAAE,GAAG,MAAM;IAI1C;;;OAGG;IACH,QAAQ;IAIR;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,eAAe;CAIlE;AAED;;;GAGG;AACH,qBAAa,aAAa;IAEtB;;OAEG;IACI,MAAM,EAAE;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,CAAA;KAAE;;IAHlD;;OAEG;IACI,MAAM,EAAE;QAAE,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,CAAA;KAAE;IAGpD;;;OAGG;IACH,QAAQ;IAKR;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,aAAa;CAIhE;AAGD,eAAO,MAAM,kBAAkB,IAAI,CAAC;AACpC,eAAO,MAAM,2BAA2B,IAAI,CAAC;AAE7C;;GAEG;AACH,qBAAa,uBAAuB;IAEzB,GAAG,EAAE,EAAE,EAAE;IACT,IAAI,EAAE,EAAE;gBADR,GAAG,EAAE,EAAE,EAAE,EACT,IAAI,EAAE,EAAE;WAGJ,OAAO,CAAC,GAAG,EAAE,EAAE,EAAE;IAK9B,IAAW,eAAe,WAEzB;IAED,IAAW,WAAW,WAErB;IAED,MAAM,KAAK,MAAM,gEAGhB;IAED,MAAM;IAIN;;;OAGG;IACH,QAAQ;IAIR,QAAQ;IAIR;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,uBAAuB;IAKzE;;;OAGG;IACH,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,SAAI,GAAG,uBAAuB;IAIhE,MAAM,CAAC,YAAY,CAAC,IAAI,SAAI,GAAG,uBAAuB;IAItD,MAAM,CAAC,kBAAkB,CAAC,IAAI,SAAI,GAAG,uBAAuB;IAO5D;;;OAGG;IACH,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,uBAAuB;CAGxD;AAED,qBAAa,eAAe;IAExB;;OAEG;IACI,WAAW,EAAE,WAAW;IAC/B;;OAEG;IACI,WAAW,EAAE,MAAM;IAC1B;;OAEG;IACI,eAAe,EAAE,MAAM;IAC9B;;OAEG;IACI,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC;IACnD;;OAEG;IACI,sBAAsB,EAAE,OAAO;IACtC;;OAEG;IACI,gCAAgC,EAAE,MAAM,EAAE;;IAvBjD;;OAEG;IACI,WAAW,EAAE,WAAW;IAC/B;;OAEG;IACI,WAAW,EAAE,MAAM;IAC1B;;OAEG;IACI,eAAe,EAAE,MAAM;IAC9B;;OAEG;IACI,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC;IACnD;;OAEG;IACI,sBAAsB,EAAE,OAAO;IACtC;;OAEG;IACI,gCAAgC,EAAE,MAAM,EAAE;IAGnD;;;OAGG;IACH,QAAQ;IAWR;;;OAGG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,eAAe;IAYjE;;;OAGG;IACH,MAAM,CAAC,cAAc,IAAI,eAAe;IAWxC;;;OAGG;IACH,MAAM,CAAC,QAAQ,IAAI,eAAe;CAUnC;AAED,qBAAa,mBAAmB;aAEZ,WAAW,EAAE,uBAAuB;aACpC,UAAU,EAAE,MAAM;gBADlB,WAAW,EAAE,uBAAuB,EACpC,UAAU,EAAE,MAAM;IAGpC,IAAW,eAAe,WAEzB;IAED,IAAW,WAAW,WAErB;IAED,MAAM,CAAC,KAAK;IAIZ,MAAM,CAAC,YAAY,IAAI,mBAAmB;IAI1C,MAAM,CAAC,kBAAkB,IAAI,mBAAmB;IAOhD,MAAM,CAAC,QAAQ,CAAC,GAAG,SAA4B,GAAG,mBAAmB;IAIrE;;;OAGG;IACH,QAAQ;IAIR,QAAQ;IAIR,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,mBAAmB;IAQrE,MAAM,CAAC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,mBAAmB;IAI5C,KAAK;IAIZ,2DAA2D;IAC3D,MAAM;IAIN,6CAA6C;IAC7C,MAAM,KAAK,MAAM,4DAEhB;CACF"}

package/dest/vks/verification_key.js

@@ -64,7 +64,6 @@ import { CircuitType } from '../types/shared.js';
 // TODO: find better home for these constants
 export const CIRCUIT_SIZE_INDEX = 0;
 export const CIRCUIT_PUBLIC_INPUTS_INDEX = 1;
-export const CIRCUIT_RECURSIVE_INDEX = 3;
 /**
  * Provides a 'fields' representation of a circuit's verification key
  */ export class VerificationKeyAsFields {
@@ -84,9 +83,6 @@ export const CIRCUIT_RECURSIVE_INDEX = 3;
     get circuitSize() {
         return Number(this.key[CIRCUIT_SIZE_INDEX]);
     }
-    get isRecursive() {
-        return this.key[CIRCUIT_RECURSIVE_INDEX].equals(Fr.ONE);
-    }
     static get schema() {
         // TODO(palla/schemas): Should we verify the hash matches the key when deserializing?
         return bufferSchemaFor(VerificationKeyAsFields);
@@ -200,9 +196,6 @@ export class VerificationKeyData {
     get circuitSize() {
         return this.keyAsFields.circuitSize;
     }
-    get isRecursive() {
-        return this.keyAsFields.isRecursive;
-    }
     static empty() {
         return new VerificationKeyData(VerificationKeyAsFields.makeEmpty(0), Buffer.alloc(0));
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/stdlib",
-  "version": "2.0.0-nightly.20250828",
+  "version": "2.0.0-nightly.20250830",
   "type": "module",
   "inherits": [
     "../package.common.json",
@@ -69,13 +69,13 @@
     "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules ../node_modules/.bin/jest --passWithNoTests --maxWorkers=${JEST_MAX_WORKERS:-8}"
   },
   "dependencies": {
-    "@aztec/bb.js": "2.0.0-nightly.20250828",
-    "@aztec/blob-lib": "2.0.0-nightly.20250828",
-    "@aztec/constants": "2.0.0-nightly.20250828",
-    "@aztec/ethereum": "2.0.0-nightly.20250828",
-    "@aztec/foundation": "2.0.0-nightly.20250828",
-    "@aztec/l1-artifacts": "2.0.0-nightly.20250828",
-    "@aztec/noir-noirc_abi": "2.0.0-nightly.20250828",
+    "@aztec/bb.js": "2.0.0-nightly.20250830",
+    "@aztec/blob-lib": "2.0.0-nightly.20250830",
+    "@aztec/constants": "2.0.0-nightly.20250830",
+    "@aztec/ethereum": "2.0.0-nightly.20250830",
+    "@aztec/foundation": "2.0.0-nightly.20250830",
+    "@aztec/l1-artifacts": "2.0.0-nightly.20250830",
+    "@aztec/noir-noirc_abi": "2.0.0-nightly.20250830",
     "@google-cloud/storage": "^7.15.0",
     "axios": "^1.9.0",
     "json-stringify-deterministic": "1.0.12",

package/src/interfaces/slasher.ts

@@ -7,24 +7,18 @@ export type SlasherClientType = 'empire' | 'tally';
 
 export interface SlasherConfig {
   slashOverridePayload?: EthAddress;
-  slashPayloadTtlSeconds: number; // TTL for payloads, in seconds
-  slashPruneEnabled: boolean;
+  slashMinPenaltyPercentage: number;
+  slashMaxPenaltyPercentage: number;
+  slashSelfAllowed?: boolean; // Whether to allow slashes to own validators
+  slashValidatorsAlways: EthAddress[]; // Array of validator addresses
+  slashValidatorsNever: EthAddress[]; // Array of validator addresses
+  slashInactivityTargetPercentage: number; // 0-1, 0.9 means 90%. Must be greater than 0
   slashPrunePenalty: bigint;
-  slashPruneMaxPenalty: bigint;
-  slashBroadcastedInvalidBlockEnabled: boolean;
+  slashInactivityPenalty: bigint;
   slashBroadcastedInvalidBlockPenalty: bigint;
-  slashBroadcastedInvalidBlockMaxPenalty: 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;
   slashProposeInvalidAttestationsPenalty: bigint;
-  slashProposeInvalidAttestationsMaxPenalty: bigint;
   slashAttestDescendantOfInvalidPenalty: bigint;
-  slashAttestDescendantOfInvalidMaxPenalty: bigint;
   slashUnknownPenalty: bigint;
-  slashUnknownMaxPenalty: bigint;
   slashOffenseExpirationRounds: number; // Number of rounds after which pending offenses expire
   slashMaxPayloadSize: number; // Maximum number of offenses to include in a single slash payload
   slashGracePeriodL2Slots: number; // Number of L2 slots to wait after genesis before slashing for most offenses
@@ -32,25 +26,19 @@ export interface SlasherConfig {
 
 export const SlasherConfigSchema = z.object({
   slashOverridePayload: schemas.EthAddress.optional(),
-  slashPayloadTtlSeconds: z.number(),
-  slashPruneEnabled: z.boolean(),
+  slashMinPenaltyPercentage: z.number(),
+  slashMaxPenaltyPercentage: z.number(),
+  slashValidatorsAlways: z.array(schemas.EthAddress),
+  slashValidatorsNever: z.array(schemas.EthAddress),
   slashPrunePenalty: schemas.BigInt,
-  slashPruneMaxPenalty: schemas.BigInt,
-  slashBroadcastedInvalidBlockEnabled: z.boolean(),
-  slashBroadcastedInvalidBlockPenalty: schemas.BigInt,
-  slashBroadcastedInvalidBlockMaxPenalty: schemas.BigInt,
-  slashInactivityEnabled: z.boolean(),
-  slashInactivityCreateTargetPercentage: z.number(),
-  slashInactivitySignalTargetPercentage: z.number(),
-  slashInactivityCreatePenalty: schemas.BigInt,
-  slashInactivityMaxPenalty: schemas.BigInt,
+  slashInactivityTargetPercentage: z.number(),
+  slashInactivityPenalty: schemas.BigInt,
   slashProposeInvalidAttestationsPenalty: schemas.BigInt,
-  slashProposeInvalidAttestationsMaxPenalty: schemas.BigInt,
   slashAttestDescendantOfInvalidPenalty: schemas.BigInt,
-  slashAttestDescendantOfInvalidMaxPenalty: schemas.BigInt,
   slashUnknownPenalty: schemas.BigInt,
-  slashUnknownMaxPenalty: schemas.BigInt,
   slashOffenseExpirationRounds: z.number(),
   slashMaxPayloadSize: z.number(),
   slashGracePeriodL2Slots: z.number(),
+  slashBroadcastedInvalidBlockPenalty: schemas.BigInt,
+  slashSelfAllowed: z.boolean().optional(),
 }) satisfies ZodFor<SlasherConfig>;

package/src/slashing/helpers.ts

@@ -1,4 +1,5 @@
 import { type L1RollupConstants, getEpochAtSlot, getSlotRangeForEpoch } from '../epoch-helpers/index.js';
+import type { SlasherConfig } from '../interfaces/slasher.js';
 import { type Offense, OffenseType } from './types.js';
 
 /** Returns the voting round number and voting slot within the round for a given L2 slot. */
@@ -39,6 +40,41 @@ export function getEpochsForRound(
   return epochs;
 }
 
+/** Reads the configured penalty for a given offense type from a slasher config struct */
+export function getPenaltyForOffense(
+  offense: OffenseType,
+  config: Pick<
+    SlasherConfig,
+    | 'slashAttestDescendantOfInvalidPenalty'
+    | 'slashBroadcastedInvalidBlockPenalty'
+    | 'slashPrunePenalty'
+    | 'slashUnknownPenalty'
+    | 'slashInactivityPenalty'
+    | 'slashProposeInvalidAttestationsPenalty'
+  >,
+) {
+  switch (offense) {
+    case OffenseType.VALID_EPOCH_PRUNED:
+    case OffenseType.DATA_WITHHOLDING:
+      return config.slashPrunePenalty;
+    case OffenseType.INACTIVITY:
+      return config.slashInactivityPenalty;
+    case OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS:
+    case OffenseType.PROPOSED_INCORRECT_ATTESTATIONS:
+      return config.slashProposeInvalidAttestationsPenalty;
+    case OffenseType.ATTESTED_DESCENDANT_OF_INVALID:
+      return config.slashAttestDescendantOfInvalidPenalty;
+    case OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL:
+      return config.slashBroadcastedInvalidBlockPenalty;
+    case OffenseType.UNKNOWN:
+      return config.slashUnknownPenalty;
+    default: {
+      const _: never = offense;
+      throw new Error(`Unknown offense type: ${offense}`);
+    }
+  }
+}
+
 /** Returns whether the `epochOrSlot` field for an offense references an epoch or a slot */
 export function getTimeUnitForOffense(offense: OffenseType): 'epoch' | 'slot' {
   switch (offense) {

package/src/slashing/tally.ts

@@ -1,37 +1,59 @@
-import { minBigint, sumBigint } from '@aztec/foundation/bigint';
-import type { EthAddress } from '@aztec/foundation/eth-address';
+import { sumBigint } from '@aztec/foundation/bigint';
+import { EthAddress } from '@aztec/foundation/eth-address';
 
 import type { Offense, ValidatorSlashVote } from './types.js';
 
-/** How many slashing units a validator can be slashed in consensus-based slashing */
-const MAX_SLASH_UNITS_PER_VALIDATOR = 3n;
-
 /**
  * Creates a consensus-slash vote for a given set of committees based on a set of Offenses
+ * @param offenses - Array of offenses to consider
+ * @param committees - Array of committees (each containing array of validator addresses)
+ * @param settings - Settings including slashingAmounts and optional validator override lists
  * @returns Array of ValidatorSlashVote, where each vote is how many slash units the validator in that position should be slashed
  */
 export function getSlashConsensusVotesFromOffenses(
-  offenses: Offense[],
+  offenses: Pick<Offense, 'validator' | 'amount'>[],
   committees: EthAddress[][],
-  settings: { slashingUnit: bigint },
+  settings: {
+    slashingAmounts: [bigint, bigint, bigint];
+  },
 ): ValidatorSlashVote[] {
-  const { slashingUnit } = settings;
-  const slashed: Set<string> = new Set();
+  const { slashingAmounts } = settings;
+
+  const slashedSet: Set<string> = new Set();
+
   const votes = committees.flatMap(committee =>
     committee.map(validator => {
-      if (slashed.has(validator.toString())) {
-        return 0; // Already voted for slashing this validator
+      const validatorStr = validator.toString();
+
+      // If already voted for slashing this validator, skip
+      if (slashedSet.has(validatorStr)) {
+        return 0;
       }
+
+      // Normal offense-based slashing logic
       const validatorOffenses = offenses.filter(o => o.validator.equals(validator));
       const slashAmount = sumBigint(validatorOffenses.map(o => o.amount));
-      const slashUnits = minBigint(slashAmount / slashingUnit, MAX_SLASH_UNITS_PER_VALIDATOR);
-      slashed.add(validator.toString());
+      const slashUnits = getSlashUnitsForAmount(slashAmount, slashingAmounts);
+      slashedSet.add(validatorStr);
       return Number(slashUnits);
     }),
   );
   return votes;
 }
 
+/** Returns the slash vote for the given amount to slash. */
+function getSlashUnitsForAmount(amountToSlash: bigint, slashingAmounts: [bigint, bigint, bigint]): number {
+  if (amountToSlash >= slashingAmounts[2]) {
+    return 3;
+  } else if (amountToSlash >= slashingAmounts[1]) {
+    return 2;
+  } else if (amountToSlash >= slashingAmounts[0]) {
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
 /**
  * Encodes a set of slash votes into a Buffer for use in a consensus slashing vote transaction.
  * Each vote is represented as a 2-bit value, which represents how many slashing units the validator should be slashed.

package/src/vks/verification_key.ts

@@ -80,7 +80,6 @@ export class CommitmentMap {
 // TODO: find better home for these constants
 export const CIRCUIT_SIZE_INDEX = 0;
 export const CIRCUIT_PUBLIC_INPUTS_INDEX = 1;
-export const CIRCUIT_RECURSIVE_INDEX = 3;
 
 /**
  * Provides a 'fields' representation of a circuit's verification key
@@ -104,10 +103,6 @@ export class VerificationKeyAsFields {
     return Number(this.key[CIRCUIT_SIZE_INDEX]);
   }
 
-  public get isRecursive() {
-    return this.key[CIRCUIT_RECURSIVE_INDEX].equals(Fr.ONE);
-  }
-
   static get schema() {
     // TODO(palla/schemas): Should we verify the hash matches the key when deserializing?
     return bufferSchemaFor(VerificationKeyAsFields);
@@ -271,10 +266,6 @@ export class VerificationKeyData {
     return this.keyAsFields.circuitSize;
   }
 
-  public get isRecursive() {
-    return this.keyAsFields.isRecursive;
-  }
-
   static empty() {
     return new VerificationKeyData(VerificationKeyAsFields.makeEmpty(0), Buffer.alloc(0));
   }