@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.b655e406

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"}

package/dest/slashing/empire.js

@@ -0,0 +1,84 @@
+import { getRoundForSlot, getRoundsForEpoch } from './helpers.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 function isOffenseUncontroversial(offense) {
+    return offense === OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS || offense === OffenseType.PROPOSED_INCORRECT_ATTESTATIONS || offense === OffenseType.ATTESTED_DESCENDANT_OF_INVALID;
+}
+/** Extracts offense identifiers (validator, epoch, offense type) from an Empire-based SlashPayload */ export function getOffenseIdentifiersFromPayload(payload) {
+    return payload.slashes.flatMap((slash)=>slash.offenses.map((o)=>({
+                validator: slash.validator,
+                offenseType: o.offenseType,
+                epochOrSlot: o.epochOrSlot
+            })));
+}
+/** Creates ValidatorSlashes used to create an Empire-based SlashPayload from a set of Offenses */ export function offensesToValidatorSlash(offenses) {
+    return offenses.map((offense)=>({
+            validator: offense.validator,
+            amount: offense.amount,
+            offenses: [
+                {
+                    epochOrSlot: offense.epochOrSlot,
+                    offenseType: offense.offenseType
+                }
+            ]
+        }));
+}
+/**
+ * Sorts offense data by:
+ * - Uncontroversial offenses first
+ * - Slash amount (descending)
+ * - Epoch or slot (ascending, ie oldest first)
+ * - Validator address (ascending)
+ * - Offense type (descending)
+ */ export function offenseDataComparator(a, b) {
+    return Number(isOffenseUncontroversial(b.offenseType)) - Number(isOffenseUncontroversial(a.offenseType)) || Number(b.amount - a.amount) || Number(a.epochOrSlot - b.epochOrSlot) || a.validator.toString().localeCompare(b.validator.toString()) || Number(b.offenseType) - Number(a.offenseType);
+}
+/**
+ * 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 function getFirstEligibleRoundForOffense(offense, constants) {
+    // TODO(palla/slash): Check for off-by-ones
+    switch(offense.offenseType){
+        // Inactivity is detected at the end of the epoch, so we flag it as detected in the first fresh round for the next epoch
+        case OffenseType.INACTIVITY:
+            {
+                const epoch = offense.epochOrSlot;
+                const detectedEpoch = epoch + 1n;
+                return getRoundsForEpoch(detectedEpoch, constants)[0] + 1n;
+            }
+        // These offenses are detected once an epoch is pruned, which happens after the proof submission window
+        case OffenseType.VALID_EPOCH_PRUNED:
+        case OffenseType.DATA_WITHHOLDING:
+            {
+                // TODO(palla/slash): Check for off-by-ones especially here
+                const epoch = offense.epochOrSlot;
+                const detectedEpoch = epoch + BigInt(constants.proofSubmissionEpochs);
+                return getRoundsForEpoch(detectedEpoch, constants)[0] + 1n;
+            }
+        // These offenses are detected immediately in the slot they occur, so we assume they are detected in the first round for the following slot
+        case OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS:
+        case OffenseType.PROPOSED_INCORRECT_ATTESTATIONS:
+        case OffenseType.ATTESTED_DESCENDANT_OF_INVALID:
+        case OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL:
+            {
+                const slot = offense.epochOrSlot;
+                const detectedSlot = slot + 1n;
+                return getRoundForSlot(detectedSlot, constants).round + 1n;
+            }
+        // Assume these are epoch-based offenses, even though we should never have to process these
+        case OffenseType.UNKNOWN:
+            {
+                const epoch = offense.epochOrSlot;
+                const detectedEpoch = epoch + 1n;
+                return getRoundsForEpoch(detectedEpoch, constants)[0] + 1n;
+            }
+        default:
+            {
+                const _ = offense.offenseType;
+                throw new Error(`Unknown offense type: ${offense.offenseType}`);
+            }
+    }
+}

package/dest/slashing/helpers.d.ts

@@ -0,0 +1,35 @@
+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: {
+    slashingRoundSize: number;
+}): {
+    round: bigint;
+    votingSlot: bigint;
+};
+/** Returns the voting round(s) lower and upper bounds (inclusive) covered by the given epoch */
+export declare function getRoundsForEpoch(epoch: bigint, constants: {
+    slashingRoundSize: number;
+    epochDuration: number;
+}): [bigint, bigint];
+/** Returns the epochs spanned during a given slashing round */
+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' | 'slashDataWithholdingPenalty' | '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. */
+export declare function getSlotForOffense(offense: Pick<Offense, 'epochOrSlot' | 'offenseType'>, constants: Pick<L1RollupConstants, 'epochDuration'>): bigint;
+/** Returns the epoch for a given offense. If the offense type or epoch is not defined, returns undefined. */
+export declare function getEpochForOffense(offense: Pick<Offense, 'epochOrSlot' | 'offenseType'>, constants: Pick<L1RollupConstants, 'epochDuration'>): bigint;
+export declare function getEpochForOffense(offense: Partial<Pick<Offense, 'epochOrSlot' | 'offenseType'>>, constants: Pick<L1RollupConstants, 'epochDuration'>): bigint | undefined;
+/** Returns the slashing round in which a given offense occurred. */
+export declare function getRoundForOffense(offense: Pick<Offense, 'epochOrSlot' | 'offenseType'>, constants: {
+    slashingRoundSize: number;
+    epochDuration: number;
+}): bigint;
+//# sourceMappingURL=helpers.d.ts.map

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

@@ -0,0 +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,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,6BAA6B,GAC7B,qBAAqB,GACrB,wBAAwB,GACxB,wCAAwC,CAC3C,UAuBF;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,6GAA6G;AAC7G,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,aAAa,GAAG,aAAa,CAAC,EACrD,SAAS,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,GAClD,MAAM,CAAC;AACV,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,aAAa,GAAG,aAAa,CAAC,CAAC,EAC9D,SAAS,EAAE,IAAI,CAAC,iBAAiB,EAAE,eAAe,CAAC,GAClD,MAAM,GAAG,SAAS,CAAC;AAYtB,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

@@ -0,0 +1,89 @@
+import { getEpochAtSlot, getSlotRangeForEpoch } from '../epoch-helpers/index.js';
+import { OffenseType } from './types.js';
+/** Returns the voting round number and voting slot within the round for a given L2 slot. */ export function getRoundForSlot(slot, constants) {
+    const roundSize = BigInt(constants.slashingRoundSize);
+    const round = slot / roundSize;
+    const votingSlot = slot % roundSize;
+    return {
+        round,
+        votingSlot
+    };
+}
+/** Returns the voting round(s) lower and upper bounds (inclusive) covered by the given epoch */ export function getRoundsForEpoch(epoch, constants) {
+    const [start, end] = getSlotRangeForEpoch(epoch, constants);
+    const startRound = getRoundForSlot(start, constants).round;
+    const endRound = getRoundForSlot(end, constants).round;
+    return [
+        startRound,
+        endRound
+    ];
+}
+/** Returns the epochs spanned during a given slashing round */ export function getEpochsForRound(round, constants) {
+    const epochs = [];
+    const firstSlot = round * BigInt(constants.slashingRoundSize);
+    const lastSlot = firstSlot + BigInt(constants.slashingRoundSize) - 1n;
+    const startEpoch = getEpochAtSlot(firstSlot, constants);
+    const endEpoch = getEpochAtSlot(lastSlot, constants);
+    for(let epoch = startEpoch; epoch <= endEpoch; epoch++){
+        epochs.push(epoch);
+    }
+    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:
+            return config.slashPrunePenalty;
+        case OffenseType.DATA_WITHHOLDING:
+            return config.slashDataWithholdingPenalty;
+        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 _exhaustiveCheck = offense;
+                throw new Error(`Unknown offense type: ${_exhaustiveCheck}`);
+            }
+    }
+}
+/** 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:
+        case OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL:
+        case OffenseType.PROPOSED_INCORRECT_ATTESTATIONS:
+        case OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS:
+            return 'slot';
+        case OffenseType.INACTIVITY:
+        case OffenseType.DATA_WITHHOLDING:
+        case OffenseType.UNKNOWN:
+        case OffenseType.VALID_EPOCH_PRUNED:
+            return 'epoch';
+        default:
+            {
+                const _exhaustiveCheck = offense;
+                throw new Error(`Unknown offense type: ${_exhaustiveCheck}`);
+            }
+    }
+}
+/** Returns the slot for a given offense. If the offense references an epoch, returns the first slot of the epoch. */ export function getSlotForOffense(offense, constants) {
+    const { epochOrSlot, offenseType } = offense;
+    return getTimeUnitForOffense(offenseType) === 'epoch' ? epochOrSlot * BigInt(constants.epochDuration) : epochOrSlot;
+}
+export function getEpochForOffense(offense, constants) {
+    const { epochOrSlot, offenseType } = offense;
+    if (epochOrSlot === undefined || offenseType === undefined) {
+        return undefined;
+    }
+    return getTimeUnitForOffense(offenseType) === 'epoch' ? epochOrSlot : epochOrSlot / BigInt(constants.epochDuration);
+}
+/** Returns the slashing round in which a given offense occurred. */ export function getRoundForOffense(offense, constants) {
+    const slot = getSlotForOffense(offense, constants);
+    return getRoundForSlot(slot, constants).round;
+}

package/dest/slashing/index.d.ts

@@ -0,0 +1,7 @@
+export * from './types.js';
+export * from './interfaces.js';
+export * from './helpers.js';
+export * from './empire.js';
+export * from './tally.js';
+export * from './serialization.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/slashing/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,oBAAoB,CAAC"}

package/dest/slashing/index.js

@@ -0,0 +1,6 @@
+export * from './types.js';
+export * from './interfaces.js';
+export * from './helpers.js';
+export * from './empire.js';
+export * from './tally.js';
+export * from './serialization.js';

package/dest/slashing/interfaces.d.ts

@@ -0,0 +1,11 @@
+import type { ProposerSlashAction } from './types.js';
+export interface ProposerSlashActionProvider {
+    /**
+     * Returns the actions to take for the proposer in the current slot.
+     * This can include creating a slash payload or other actions.
+     * @param slotNumber - The current slot number
+     * @returns The actions to take
+     */
+    getProposerActions(slotNumber: bigint): Promise<ProposerSlashAction[]>;
+}
+//# sourceMappingURL=interfaces.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces.d.ts","sourceRoot":"","sources":["../../src/slashing/interfaces.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAEtD,MAAM,WAAW,2BAA2B;IAC1C;;;;;OAKG;IACH,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAAC;CACxE"}

package/dest/slashing/interfaces.js

@@ -0,0 +1 @@
+export { };

package/dest/slashing/serialization.d.ts

@@ -0,0 +1,8 @@
+import type { Offense, SlashPayload, SlashPayloadRound } from './types.js';
+export declare function serializeOffense(offense: Offense): Buffer;
+export declare function deserializeOffense(buffer: Buffer): Offense;
+export declare function serializeSlashPayload(payload: SlashPayload): Buffer;
+export declare function deserializeSlashPayload(buffer: Buffer): SlashPayload;
+export declare function serializeSlashPayloadRound(payload: SlashPayloadRound): Buffer;
+export declare function deserializeSlashPayloadRound(buffer: Buffer): SlashPayloadRound;
+//# sourceMappingURL=serialization.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"serialization.d.ts","sourceRoot":"","sources":["../../src/slashing/serialization.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,OAAO,EAEP,YAAY,EACZ,iBAAiB,EAGlB,MAAM,YAAY,CAAC;AAEpB,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,CAOzD;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAQ1D;AAiCD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CAOnE;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,CAOpE;AAED,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,iBAAiB,GAAG,MAAM,CAS7E;AAED,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,MAAM,GAAG,iBAAiB,CAU9E"}

package/dest/slashing/serialization.js

@@ -0,0 +1,78 @@
+import { times } from '@aztec/foundation/collection';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { BufferReader, bigintToUInt64BE, bigintToUInt128BE, serializeToBuffer } from '@aztec/foundation/serialize';
+export function serializeOffense(offense) {
+    return serializeToBuffer(offense.validator, bigintToUInt128BE(offense.amount), offense.offenseType, bigintToUInt64BE(offense.epochOrSlot));
+}
+export function deserializeOffense(buffer) {
+    const reader = BufferReader.asReader(buffer);
+    const validator = reader.readObject(EthAddress);
+    const amount = reader.readUInt128();
+    const offense = reader.readNumber();
+    const epochOrSlot = reader.readUInt64();
+    return {
+        validator,
+        amount,
+        offenseType: offense,
+        epochOrSlot
+    };
+}
+function serializeValidatorSlashOffense(offense) {
+    return serializeToBuffer(bigintToUInt64BE(offense.epochOrSlot), offense.offenseType);
+}
+function deserializeValidatorSlashOffense(buffer) {
+    const reader = BufferReader.asReader(buffer);
+    return {
+        epochOrSlot: reader.readUInt64(),
+        offenseType: reader.readNumber()
+    };
+}
+function serializeValidatorSlash(slash) {
+    return serializeToBuffer(slash.validator, bigintToUInt128BE(slash.amount), slash.offenses.length, slash.offenses.map(serializeValidatorSlashOffense));
+}
+function deserializeValidatorSlash(buffer) {
+    const reader = BufferReader.asReader(buffer);
+    const validator = reader.readObject(EthAddress);
+    const amount = reader.readUInt128();
+    const offensesCount = reader.readNumber();
+    const offenses = times(offensesCount, ()=>deserializeValidatorSlashOffense(reader));
+    return {
+        validator,
+        amount,
+        offenses
+    };
+}
+export function serializeSlashPayload(payload) {
+    return serializeToBuffer(payload.address, payload.slashes.length, payload.slashes.map(serializeValidatorSlash), bigintToUInt64BE(payload.timestamp));
+}
+export function deserializeSlashPayload(buffer) {
+    const reader = BufferReader.asReader(buffer);
+    const address = reader.readObject(EthAddress);
+    const slashesCount = reader.readNumber();
+    const slashes = times(slashesCount, ()=>deserializeValidatorSlash(reader));
+    const timestamp = reader.readUInt64();
+    return {
+        address,
+        slashes,
+        timestamp
+    };
+}
+export function serializeSlashPayloadRound(payload) {
+    return serializeToBuffer(payload.address, payload.slashes.length, payload.slashes.map(serializeValidatorSlash), bigintToUInt64BE(payload.timestamp), Number(payload.votes), bigintToUInt64BE(payload.round));
+}
+export function deserializeSlashPayloadRound(buffer) {
+    const reader = BufferReader.asReader(buffer);
+    const address = reader.readObject(EthAddress);
+    const slashesCount = reader.readNumber();
+    const slashes = times(slashesCount, ()=>deserializeValidatorSlash(reader));
+    const timestamp = reader.readUInt64();
+    const votes = BigInt(reader.readNumber());
+    const round = reader.readUInt64();
+    return {
+        address,
+        slashes,
+        timestamp,
+        votes,
+        round
+    };
+}

package/dest/slashing/tally.d.ts

@@ -0,0 +1,23 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { PartialBy } from '@aztec/foundation/types';
+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 epochsForCommittees - Array of epochs corresponding to each committee
+ * @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: PartialBy<Offense, 'epochOrSlot'>[], committees: EthAddress[][], epochsForCommittees: bigint[], settings: {
+    slashingAmounts: [bigint, bigint, bigint];
+    epochDuration: number;
+}): ValidatorSlashVote[];
+/**
+ * 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.
+ * @param votes - The array of slash votes to encode
+ * @returns A Buffer containing the encoded slash votes
+ */
+export declare function encodeSlashConsensusVotes(votes: ValidatorSlashVote[]): Buffer;
+//# sourceMappingURL=tally.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tally.d.ts","sourceRoot":"","sources":["../../src/slashing/tally.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGzD,OAAO,KAAK,EAAE,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAE9D;;;;;;;GAOG;AACH,wBAAgB,kCAAkC,CAChD,QAAQ,EAAE,SAAS,CAAC,OAAO,EAAE,aAAa,CAAC,EAAE,EAC7C,UAAU,EAAE,UAAU,EAAE,EAAE,EAC1B,mBAAmB,EAAE,MAAM,EAAE,EAC7B,QAAQ,EAAE;IACR,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,aAAa,EAAE,MAAM,CAAC;CACvB,GACA,kBAAkB,EAAE,CA2BtB;AAeD;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,kBAAkB,EAAE,GAAG,MAAM,CAe7E"}

package/dest/slashing/tally.js

@@ -0,0 +1,60 @@
+import { sumBigint } from '@aztec/foundation/bigint';
+import { getEpochForOffense } from './helpers.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 epochsForCommittees - Array of epochs corresponding to each committee
+ * @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, epochsForCommittees, settings) {
+    const { slashingAmounts } = settings;
+    if (committees.length !== epochsForCommittees.length) {
+        throw new Error('committees and epochsForCommittees must have the same length');
+    }
+    const votes = committees.flatMap((committee, committeeIndex)=>{
+        const committeeEpoch = epochsForCommittees[committeeIndex];
+        return committee.map((validator)=>{
+            // Find offenses for this validator in this specific epoch.
+            // If an offense has no epoch, it is considered for all epochs due to a slashAlways setting.
+            const validatorOffenses = offenses.filter((o)=>o.validator.equals(validator) && (o.epochOrSlot === undefined || getEpochForOffense(o, settings) === committeeEpoch));
+            // Sum up the penalties for this validator in this epoch
+            const slashAmount = sumBigint(validatorOffenses.map((o)=>o.amount));
+            const slashUnits = getSlashUnitsForAmount(slashAmount, slashingAmounts);
+            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.
+ * @param votes - The array of slash votes to encode
+ * @returns A Buffer containing the encoded slash votes
+ */ export function encodeSlashConsensusVotes(votes) {
+    if (votes.length % 4 !== 0) {
+        throw new Error('Votes array must have a length that is a multiple of 4');
+    }
+    const buffer = Buffer.alloc(votes.length / 4);
+    for(let i = 0; i < votes.length; i += 4){
+        // Encode votes to match Solidity's bit order (LSB to MSB)
+        // Bits 0-1: validator at index i
+        // Bits 2-3: validator at index i+1
+        // Bits 4-5: validator at index i+2
+        // Bits 6-7: validator at index i+3
+        const voteByte = votes[i] | votes[i + 1] << 2 | votes[i + 2] << 4 | votes[i + 3] << 6;
+        buffer.writeUInt8(voteByte, i / 4);
+    }
+    return buffer;
+}

package/dest/slashing/types.d.ts

@@ -0,0 +1,162 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { z } from 'zod';
+import { type ZodFor } from '../schemas/index.js';
+export declare enum OffenseType {
+    UNKNOWN = 0,
+    /** The data for proving an epoch was not publicly available, we slash its committee */
+    DATA_WITHHOLDING = 1,
+    /** An epoch was not successfully proven in time, we slash its committee */
+    VALID_EPOCH_PRUNED = 2,
+    /** A proposer failed to attest or propose during an epoch according to the Sentinel */
+    INACTIVITY = 3,
+    /** A proposer sent an invalid block proposal over the p2p network to the committee */
+    BROADCASTED_INVALID_BLOCK_PROPOSAL = 4,
+    /** A proposer pushed to L1 a block with insufficient committee attestations */
+    PROPOSED_INSUFFICIENT_ATTESTATIONS = 5,
+    /** A proposer pushed to L1 a block with incorrect committee attestations (ie signature from a non-committee member) */
+    PROPOSED_INCORRECT_ATTESTATIONS = 6,
+    /** A committee member attested to a block that was built as a descendent of an invalid block (as in a block with invalid attestations) */
+    ATTESTED_DESCENDANT_OF_INVALID = 7
+}
+export declare function getOffenseTypeName(offense: OffenseType): "unknown" | "data_withholding" | "valid_epoch_pruned" | "inactivity" | "broadcasted_invalid_block_proposal" | "proposed_insufficient_attestations" | "proposed_incorrect_attestations" | "attested_descendant_of_invalid";
+export declare const OffenseTypeSchema: z.ZodNativeEnum<typeof OffenseType>;
+export declare const OffenseToBigInt: Record<OffenseType, bigint>;
+export declare function bigIntToOffense(offense: bigint): OffenseType;
+export type Offense = {
+    validator: EthAddress;
+    amount: bigint;
+    offenseType: OffenseType;
+    epochOrSlot: bigint;
+};
+export type OffenseIdentifier = Pick<Offense, 'validator' | 'offenseType' | 'epochOrSlot'>;
+export declare const OffenseSchema: z.ZodObject<{
+    validator: ZodFor<EthAddress>;
+    amount: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+    offenseType: z.ZodNativeEnum<typeof OffenseType>;
+    epochOrSlot: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+}, "strip", z.ZodTypeAny, {
+    amount: bigint;
+    validator: EthAddress;
+    offenseType: OffenseType;
+    epochOrSlot: bigint;
+}, {
+    amount: string | number | bigint;
+    offenseType: OffenseType;
+    epochOrSlot: string | number | bigint;
+    validator?: any;
+}>;
+/** Offense by a validator in the context of a slash payload */
+export type ValidatorSlashOffense = {
+    epochOrSlot: bigint;
+    offenseType: OffenseType;
+};
+/** Slashed amount and total offenses by a validator in the context of a slash payload */
+export type ValidatorSlash = {
+    validator: EthAddress;
+    amount: bigint;
+    offenses: ValidatorSlashOffense[];
+};
+/** Slash payload as published by the empire slash proposer */
+export type SlashPayload = {
+    address: EthAddress;
+    slashes: ValidatorSlash[];
+    timestamp: bigint;
+};
+/** Slash payload with round information from empire slash proposer */
+export type SlashPayloadRound = SlashPayload & {
+    votes: bigint;
+    round: bigint;
+};
+export declare const SlashPayloadRoundSchema: z.ZodObject<{
+    address: ZodFor<EthAddress>;
+    timestamp: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+    votes: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+    round: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+    slashes: z.ZodArray<z.ZodObject<{
+        validator: ZodFor<EthAddress>;
+        amount: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+        offenses: z.ZodArray<z.ZodObject<{
+            offenseType: z.ZodNativeEnum<typeof OffenseType>;
+            epochOrSlot: z.ZodPipeline<z.ZodUnion<[z.ZodBigInt, z.ZodNumber, z.ZodString]>, z.ZodBigInt>;
+        }, "strip", z.ZodTypeAny, {
+            offenseType: OffenseType;
+            epochOrSlot: bigint;
+        }, {
+            offenseType: OffenseType;
+            epochOrSlot: string | number | bigint;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        amount: bigint;
+        validator: EthAddress;
+        offenses: {
+            offenseType: OffenseType;
+            epochOrSlot: bigint;
+        }[];
+    }, {
+        amount: string | number | bigint;
+        offenses: {
+            offenseType: OffenseType;
+            epochOrSlot: string | number | bigint;
+        }[];
+        validator?: any;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    timestamp: bigint;
+    address: EthAddress;
+    votes: bigint;
+    round: bigint;
+    slashes: {
+        amount: bigint;
+        validator: EthAddress;
+        offenses: {
+            offenseType: OffenseType;
+            epochOrSlot: bigint;
+        }[];
+    }[];
+}, {
+    timestamp: string | number | bigint;
+    votes: string | number | bigint;
+    round: string | number | bigint;
+    slashes: {
+        amount: string | number | bigint;
+        offenses: {
+            offenseType: OffenseType;
+            epochOrSlot: string | number | bigint;
+        }[];
+        validator?: any;
+    }[];
+    address?: any;
+}>;
+/** Votes for a validator slash in the consensus slash proposer */
+export type ValidatorSlashVote = number;
+export type ProposerSlashAction = 
+/** Create a new slash payload on an empire-based slash proposer */
+{
+    type: 'create-empire-payload';
+    data: ValidatorSlash[];
+}
+/** Vote for a slashing payload on an empire-based slash proposer */
+ | {
+    type: 'vote-empire-payload';
+    payload: EthAddress;
+}
+/** Execute a slashing payload on an empire-based slash proposer */
+ | {
+    type: 'execute-empire-payload';
+    round: bigint;
+}
+/** Vote for offenses on a consensus slashing proposer */
+ | {
+    type: 'vote-offenses';
+    votes: ValidatorSlashVote[];
+    committees: EthAddress[][];
+    round: bigint;
+}
+/** Execute a slashing round on a consensus slashing proposer */
+ | {
+    type: 'execute-slash';
+    committees: EthAddress[][];
+    round: bigint;
+};
+export type ProposerSlashActionType = ProposerSlashAction['type'];
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/slashing/types.ts"],"names":[],"mappings":"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"}