@aztec/ethereum 0.0.1-commit.3100065 → 0.0.1-commit.330febf

package/src/l1_tx_utils/l1_fee_analyzer.ts

@@ -791,9 +791,6 @@ export class L1FeeAnalyzer {
     });
   }
 
-  /**
-   * Gets the minimum value from an array of bigints
-   */
   private minBigInt(values: bigint[]): bigint {
     if (values.length === 0) {
       return 0n;
@@ -801,3 +798,78 @@ export class L1FeeAnalyzer {
     return values.reduce((min, val) => (val < min ? val : min), values[0]);
   }
 }
+
+/** Per-block fee data for one mined L1 block, used to diagnose whether a tx was underpriced for it. */
+export interface WindowBlockFees {
+  blockNumber: bigint;
+  timestamp: bigint;
+  baseFeePerGas: bigint;
+  /** 75th percentile priority fee among the block's txs (gas-weighted, from eth_feeHistory). */
+  p75PriorityFee: bigint;
+  /** Minimum priority fee among all included txs — the inclusion bar for that block. */
+  minIncludedPriorityFee: bigint;
+  blockBlobsFull: boolean;
+  includedBlobCount: number;
+}
+
+/** Safety bound on how far back the window scan walks if the chain head is far ahead of the window. */
+const MAX_WINDOW_SCAN_BLOCKS = 64;
+
+/**
+ * Reads the already-mined L1 blocks whose timestamps fall in [windowStartS, windowEndS) — the L1
+ * inclusion window of an L2 slot — and extracts per-block fee data. Walks block headers to map the
+ * window to block numbers, then reads the priority-fee stats from a single eth_feeHistory call
+ * (percentile 0 is the cheapest included tx, i.e. the inclusion bar), so no transaction bodies are
+ * ever downloaded. Historical reads only, so it never waits on a future block. Returns the blocks in
+ * chronological order, [] on error, or the subset mined so far if the window is still in progress.
+ * Never throws.
+ */
+export async function captureWindowBlockFees(
+  client: ViemClient,
+  windowStartS: bigint,
+  windowEndS: bigint,
+): Promise<WindowBlockFees[]> {
+  try {
+    let current = await client.getBlock({ blockTag: 'latest' });
+    const inWindow: (typeof current)[] = [];
+    let scanned = 0;
+    // Walk back from the head, collecting blocks inside the window and skipping any past its end,
+    // until we cross below the window start (or hit the safety cap / genesis).
+    while (current.timestamp >= windowStartS && scanned < MAX_WINDOW_SCAN_BLOCKS) {
+      if (current.timestamp < windowEndS) {
+        inWindow.push(current);
+      }
+      if (current.number === 0n) {
+        break;
+      }
+      current = await client.getBlock({ blockNumber: current.number - 1n });
+      scanned++;
+    }
+    if (inWindow.length === 0) {
+      return [];
+    }
+    inWindow.reverse();
+    const newest = inWindow[inWindow.length - 1];
+    const feeHistory = await client.getFeeHistory({
+      blockCount: Number(newest.number - inWindow[0].number) + 1,
+      blockNumber: newest.number,
+      rewardPercentiles: [0, 75],
+    });
+    return inWindow.map(block => {
+      const idx = Number(block.number - feeHistory.oldestBlock);
+      const [minIncludedPriorityFee, p75PriorityFee] = feeHistory.reward?.[idx] ?? [0n, 0n];
+      const blobsInBlock = block.blobGasUsed ? Number(block.blobGasUsed / GAS_PER_BLOB) : 0;
+      return {
+        blockNumber: block.number,
+        timestamp: block.timestamp,
+        baseFeePerGas: block.baseFeePerGas ?? 0n,
+        p75PriorityFee,
+        minIncludedPriorityFee,
+        blockBlobsFull: blobsInBlock >= getMaxBlobCapacity(block.timestamp),
+        includedBlobCount: blobsInBlock,
+      };
+    });
+  } catch {
+    return [];
+  }
+}

package/src/l1_tx_utils/l1_tx_utils.ts

@@ -36,6 +36,7 @@ import {
   type L1TxConfig,
   type L1TxRequest,
   type L1TxState,
+  L1TxTimeoutError,
   type SigningCallback,
   TerminalTxUtilsState,
   TxUtilsState,
@@ -306,6 +307,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
         txConfigOverrides: gasConfigOverrides ?? {},
         sentAtL1Ts: now,
         lastSentAtL1Ts: now,
+        gasPriceHistory: [baseState.gasPrice],
       };
 
       // And persist it
@@ -504,6 +506,7 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
         if (timePassed >= stallTimeMs && attempts <= maxSpeedUpAttempts) {
           const newGasPrice = await this.getGasPrice(gasConfig, isBlobTx, attempts, state.gasPrice);
           state.gasPrice = newGasPrice;
+          state.gasPriceHistory?.push(newGasPrice);
 
           this.logger.debug(
             `Tx ${currentTxHash} with nonce ${nonce} from ${account} appears stuck. ` +
@@ -672,8 +675,22 @@ export class L1TxUtils extends ReadOnlyL1TxUtils {
     blobInputs?: L1BlobInputs,
   ): Promise<{ receipt: TransactionReceipt; state: L1TxState }> {
     const { state } = await this.sendTransaction(request, gasConfig, blobInputs);
-    const receipt = await this.monitorTransaction(state);
-    return { receipt, state };
+    try {
+      const receipt = await this.monitorTransaction(state);
+      return { receipt, state };
+    } catch (err) {
+      if (err instanceof TimeoutError) {
+        // Snapshot the ladder now: the fire-and-forget cancellation mutates state.gasPrice moments later.
+        throw new L1TxTimeoutError(err.message, {
+          gasPriceHistory: state.gasPriceHistory ? [...state.gasPriceHistory] : undefined,
+          finalGasPrice: state.gasPrice,
+          attempts: state.txHashes.length,
+          nonce: state.nonce,
+          gasLimit: state.gasLimit,
+        });
+      }
+      throw err;
+    }
   }
 
   public override async simulate(

package/src/l1_tx_utils/types.ts

@@ -1,4 +1,5 @@
 import type { BlobKzgInstance } from '@aztec/blob-lib/types';
+import { TimeoutError } from '@aztec/foundation/error';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import type { ViemTransactionSignature } from '@aztec/foundation/eth-signature';
 
@@ -55,6 +56,12 @@ export type L1TxState = {
   cancelTxHashes: Hex[];
   gasLimit: bigint;
   gasPrice: GasPrice;
+  /**
+   * Prices used for each attempt (initial send followed by each speed-up), in order. Always set on
+   * newly sent txs; optional because states restored from the state store predate the field.
+   * In-memory only — not persisted by the state store.
+   */
+  gasPriceHistory?: GasPrice[];
   txConfigOverrides: L1TxConfig;
   request: L1TxRequest;
   status: TxUtilsState;
@@ -83,3 +90,28 @@ export class DroppedTransactionError extends Error {
     this.name = 'DroppedTransactionError';
   }
 }
+
+/** Snapshot of what a timed-out L1 tx tried to pay, taken when the timeout is raised. */
+export type TimedOutTxState = {
+  /** Prices used across the initial send and each speed-up, in order (undefined only for restored states). */
+  gasPriceHistory?: GasPrice[];
+  /** The last price the tx was sent at before timing out. */
+  finalGasPrice: GasPrice;
+  /** Number of send attempts (initial + speed-ups). */
+  attempts: number;
+  nonce: number;
+  gasLimit: bigint;
+};
+
+/**
+ * Thrown by sendAndMonitorTransaction when a tx times out. Subclasses TimeoutError so existing
+ * `instanceof TimeoutError` checks keep working, while carrying the gas-price ladder for diagnostics.
+ */
+export class L1TxTimeoutError extends TimeoutError {
+  constructor(
+    message: string,
+    public readonly txState: TimedOutTxState,
+  ) {
+    super(message);
+  }
+}

package/src/queries.ts

@@ -186,5 +186,11 @@ export async function getL1ContractsConfig(
     slashAmountMedium: slashingAmounts[1],
     slashAmountLarge: slashingAmounts[2],
     initialEthPerFeeAsset: DefaultL1ContractsConfig.initialEthPerFeeAsset,
+    // Not exposed by the rollup contract; fall back to defaults like the other non-on-chain fields above.
+    entryQueueBootstrapValidatorSetSize: DefaultL1ContractsConfig.entryQueueBootstrapValidatorSetSize,
+    entryQueueBootstrapFlushSize: DefaultL1ContractsConfig.entryQueueBootstrapFlushSize,
+    entryQueueFlushSizeMin: DefaultL1ContractsConfig.entryQueueFlushSizeMin,
+    entryQueueFlushSizeQuotient: DefaultL1ContractsConfig.entryQueueFlushSizeQuotient,
+    entryQueueMaxFlushSize: DefaultL1ContractsConfig.entryQueueMaxFlushSize,
   };
 }

package/src/test/eth_cheat_codes.ts

@@ -505,19 +505,40 @@ export class EthCheatCodes {
    * reorg is needed because anvil applies a new gas limit only to future blocks: without it the just-mined
    * blocks would keep the tiny gas limit, and an `eth_call` against `latest` (whose gas is capped by the
    * block gas limit) would revert with "intrinsic gas too high".
+   *
+   * The replacement blocks advance L1 time. `anvil_reorg` stamps each replacement as `parent + N*interval`,
+   * so on its own it would freeze L1 time at the parent timestamp; callers that measure elapsed L1 time
+   * (L1TxUtils stall/timeout detection, `syncDateProvider`-driven slot advancement) rely on it moving
+   * forward. We reproduce the wall-clock advance the mine step just made (at least 1s per block) via a
+   * temporary block-timestamp interval, then restore any pre-existing interval.
    */
   public async mineEmptyBlock(blockCount: number = 1): Promise<void> {
     await this.execWithPausedAnvil(async () => {
       const originalGasLimit = await this.getBlockGasLimit();
+      const parentTimestamp = await this.lastBlockTimestamp();
+      // anvil has no getter for the block-timestamp interval, but the pending block is stamped
+      // `latest + interval`, so this delta is the standing interval (0 when none is set).
+      const priorInterval = (await this.nextBlockTimestamp()) - parentTimestamp;
       try {
         await this.setBlockGasLimit(1n);
         await this.doMine(blockCount);
       } finally {
         await this.setBlockGasLimit(originalGasLimit);
       }
+      const advance = (await this.lastBlockTimestamp()) - parentTimestamp;
+      const perBlockInterval = Math.max(1, Math.floor(advance / blockCount));
       // Replace the tiny-gas-limit blocks with empty blocks at the restored gas limit, keeping the same
-      // height and timestamps. The reorged-out blocks held no transactions, so nothing returns to the pool.
-      await this.doRpcCall('anvil_reorg', [blockCount, []]);
+      // height. The reorged-out blocks held no transactions, so nothing returns to the pool.
+      await this.doRpcCall('anvil_setBlockTimestampInterval', [perBlockInterval]);
+      try {
+        await this.doRpcCall('anvil_reorg', [blockCount, []]);
+      } finally {
+        if (priorInterval > 0) {
+          await this.doRpcCall('anvil_setBlockTimestampInterval', [priorInterval]);
+        } else {
+          await this.doRpcCall('anvil_removeBlockTimestampInterval', []);
+        }
+      }
     });
 
     this.logger.warn(`Mined ${blockCount} empty L1 ${pluralize('block', blockCount)}`);

package/src/test/start_anvil.ts

@@ -1,10 +1,10 @@
 import { createLogger } from '@aztec/foundation/log';
 import { makeBackoff, retry } from '@aztec/foundation/retry';
 import type { TestDateProvider } from '@aztec/foundation/timer';
-import { fileURLToPath } from '@aztec/foundation/url';
 
 import { type ChildProcess, spawn } from 'child_process';
-import { dirname, resolve } from 'path';
+
+import { resolveFoundryBinary } from '../foundry_binary.js';
 
 /** Minimal interface matching the @viem/anvil Anvil shape used by callers. */
 export interface Anvil {
@@ -14,6 +14,30 @@ export interface Anvil {
   stop(): Promise<void>;
 }
 
+// Watchdog wrapper: instead of spawning anvil directly, we spawn a small bash supervisor that runs
+// anvil as a background child and polls its own parent (this node process). If the parent dies for
+// ANY reason — including SIGKILL / crash / OOM, where node's own exit handlers never run — the poll
+// loop ends and the EXIT trap reaps anvil. The script is inlined (rather than shipped as a `.sh`) so
+// it works from the published npm tarball too, and the resolved anvil binary is passed via
+// `$ANVIL_BIN` so it works without `anvil` on PATH.
+//
+// `$@` is the anvil argv; `bash -c <script> bash <...args>` puts the args in `$@` and `$0` = 'bash'.
+//
+// The EXIT trap reaps anvil; INT/TERM just `exit` (which fires the EXIT trap) so a signal terminates
+// the supervisor promptly instead of being swallowed — a trapped TERM does NOT terminate the shell,
+// so trapping the kill directly on TERM would leave the poll loop running and the caller's teardown
+// hanging until its SIGKILL escalation. `sleep & wait` makes the poll interruptible, so INT/TERM are
+// handled immediately rather than after the current `sleep` returns.
+const ANVIL_WATCHDOG = `
+set -u
+parent=$PPID
+"$ANVIL_BIN" "$@" &
+anvil_pid=$!
+trap 'kill "$anvil_pid" 2>/dev/null' EXIT
+trap 'exit 0' INT TERM
+while kill -0 "$parent" 2>/dev/null; do sleep 1 & wait $!; done
+`;
+
 /**
  * Ensures there's a running Anvil instance and returns the RPC URL.
  */
@@ -42,7 +66,7 @@ export async function startAnvil(
     dateProvider?: TestDateProvider;
   } = {},
 ): Promise<{ anvil: Anvil; methodCalls?: string[]; rpcUrl: string; stop: () => Promise<void> }> {
-  const anvilBinary = resolve(dirname(fileURLToPath(import.meta.url)), '../../', 'scripts/anvil_kill_wrapper.sh');
+  const anvilBinary = resolveFoundryBinary('anvil');
   const logger = opts.log ? createLogger('ethereum:anvil') : undefined;
   const methodCalls = opts.captureMethodCalls ? ([] as string[]) : undefined;
 
@@ -50,6 +74,9 @@ export async function startAnvil(
 
   const anvil = await retry(
     async () => {
+      // `--port 0` lets anvil bind an OS-assigned ephemeral port; the actual port is read back from
+      // its "Listening on host:port" stdout below, so independent suites can spawn their own anvil
+      // in parallel without fighting over a fixed port.
       const port = opts.port ?? (process.env.ANVIL_PORT ? parseInt(process.env.ANVIL_PORT) : 8545);
       const args: string[] = [
         '--host',
@@ -71,9 +98,11 @@ export async function startAnvil(
       }
       args.push('--slots-in-an-epoch', String(opts.slotsInAnEpoch ?? 1));
 
-      const child = spawn(anvilBinary, args, {
+      // Spawn the watchdog (see ANVIL_WATCHDOG). It launches anvil with these args and reaps it if we
+      // die; `$0` is 'bash' and `$@` is the anvil argv.
+      const child = spawn('bash', ['-c', ANVIL_WATCHDOG, 'bash', ...args], {
         stdio: ['ignore', 'pipe', 'pipe'],
-        env: { ...process.env, RAYON_NUM_THREADS: '1' },
+        env: { ...process.env, ANVIL_BIN: anvilBinary, RAYON_NUM_THREADS: '1' },
       });
 
       // Wait for "Listening on" or an early exit.
@@ -183,7 +212,10 @@ function syncDateProviderFromAnvilOutput(text: string, dateProvider: TestDatePro
   }
 }
 
-/** Send SIGTERM, wait up to 5 s, then SIGKILL. All timers are always cleared. */
+/**
+ * Send SIGTERM to the watchdog, wait up to 5 s, then SIGKILL. The watchdog's trap forwards the
+ * signal to anvil, so terminating it tears down anvil too. All timers are always cleared.
+ */
 function killChild(child: ChildProcess): Promise<void> {
   return new Promise<void>(resolve => {
     if (child.exitCode !== null || child.killed) {

package/src/utils.ts

@@ -235,18 +235,18 @@ export function formatViemError(error: any, abi: Abi = ErrorsAbi): FormattedViem
     // If decoding fails, we fall back to the original formatting
   }
 
-  // Strip ABI from the error object before formatting. We clone first to avoid mutating the
-  // caller's error, but structuredClone throws DataCloneError on values it cannot clone (e.g.
-  // viem RPC errors carrying function-valued request context). If cloning fails, fall back to
-  // formatting the original error untouched rather than letting the clone failure mask it.
+  // Strip ABI from the error object before formatting
   if (error && typeof error === 'object') {
-    try {
-      const errorClone = structuredClone(error);
-      stripAbis(errorClone);
-      error = errorClone;
-    } catch {
-      // Leave `error` as the original; we skip stripAbis to avoid mutating the caller's object.
-    }
+    // Create a clone to avoid modifying the original
+    const errorClone = structuredClone(error);
+
+    // Helper function to recursively remove ABI properties
+
+    // Strip ABIs from the clone
+    stripAbis(errorClone);
+
+    // Use the cleaned clone for further processing
+    error = errorClone;
   }
 
   // If it's a regular Error instance, return it with its message

package/dest/generated/l1-contracts-defaults.d.ts

@@ -1,30 +0,0 @@
-/** Default L1 contracts configuration values from network-defaults.yml */
-export declare const l1ContractsDefaultEnv: {
-    readonly ETHEREUM_SLOT_DURATION: 12;
-    readonly AZTEC_SLOT_DURATION: 72;
-    readonly AZTEC_EPOCH_DURATION: 32;
-    readonly AZTEC_TARGET_COMMITTEE_SIZE: 48;
-    readonly AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 2;
-    readonly AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 2;
-    readonly AZTEC_ACTIVATION_THRESHOLD: 100000000000000000000;
-    readonly AZTEC_EJECTION_THRESHOLD: 50000000000000000000;
-    readonly AZTEC_LOCAL_EJECTION_THRESHOLD: 98000000000000000000;
-    readonly AZTEC_EXIT_DELAY_SECONDS: 172800;
-    readonly AZTEC_INBOX_LAG: 2;
-    readonly AZTEC_PROOF_SUBMISSION_EPOCHS: 1;
-    readonly AZTEC_MANA_TARGET: 100000000;
-    readonly AZTEC_PROVING_COST_PER_MANA: 100;
-    readonly AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000;
-    readonly AZTEC_SLASHER_ENABLED: true;
-    readonly AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: 4;
-    readonly AZTEC_SLASHING_LIFETIME_IN_ROUNDS: 5;
-    readonly AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS: 0;
-    readonly AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2;
-    readonly AZTEC_SLASHING_VETOER: "0x0000000000000000000000000000000000000000";
-    readonly AZTEC_SLASHING_DISABLE_DURATION: 432000;
-    readonly AZTEC_SLASH_AMOUNT_SMALL: 10000000000000000000;
-    readonly AZTEC_SLASH_AMOUNT_MEDIUM: 20000000000000000000;
-    readonly AZTEC_SLASH_AMOUNT_LARGE: 50000000000000000000;
-    readonly AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 300;
-};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibDEtY29udHJhY3RzLWRlZmF1bHRzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvZ2VuZXJhdGVkL2wxLWNvbnRyYWN0cy1kZWZhdWx0cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFHQSwwRUFBMEU7QUFDMUUsZUFBTyxNQUFNLHFCQUFxQjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0NBMkJ4QixDQUFDIn0=

package/dest/generated/l1-contracts-defaults.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"l1-contracts-defaults.d.ts","sourceRoot":"","sources":["../../src/generated/l1-contracts-defaults.ts"],"names":[],"mappings":"AAGA,0EAA0E;AAC1E,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2BxB,CAAC"}

package/dest/generated/l1-contracts-defaults.js

@@ -1,30 +0,0 @@
-// Auto-generated from spartan/environments/network-defaults.yml
-// Do not edit manually - run yarn generate to regenerate
-/** Default L1 contracts configuration values from network-defaults.yml */ export const l1ContractsDefaultEnv = {
-    ETHEREUM_SLOT_DURATION: 12,
-    AZTEC_SLOT_DURATION: 72,
-    AZTEC_EPOCH_DURATION: 32,
-    AZTEC_TARGET_COMMITTEE_SIZE: 48,
-    AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 2,
-    AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 2,
-    AZTEC_ACTIVATION_THRESHOLD: 100000000000000000000,
-    AZTEC_EJECTION_THRESHOLD: 50000000000000000000,
-    AZTEC_LOCAL_EJECTION_THRESHOLD: 98000000000000000000,
-    AZTEC_EXIT_DELAY_SECONDS: 172800,
-    AZTEC_INBOX_LAG: 2,
-    AZTEC_PROOF_SUBMISSION_EPOCHS: 1,
-    AZTEC_MANA_TARGET: 100000000,
-    AZTEC_PROVING_COST_PER_MANA: 100,
-    AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000,
-    AZTEC_SLASHER_ENABLED: true,
-    AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: 4,
-    AZTEC_SLASHING_LIFETIME_IN_ROUNDS: 5,
-    AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS: 0,
-    AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2,
-    AZTEC_SLASHING_VETOER: '0x0000000000000000000000000000000000000000',
-    AZTEC_SLASHING_DISABLE_DURATION: 432000,
-    AZTEC_SLASH_AMOUNT_SMALL: 10000000000000000000,
-    AZTEC_SLASH_AMOUNT_MEDIUM: 20000000000000000000,
-    AZTEC_SLASH_AMOUNT_LARGE: 50000000000000000000,
-    AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 300
-};

package/src/generated/l1-contracts-defaults.ts

@@ -1,32 +0,0 @@
-// Auto-generated from spartan/environments/network-defaults.yml
-// Do not edit manually - run yarn generate to regenerate
-
-/** Default L1 contracts configuration values from network-defaults.yml */
-export const l1ContractsDefaultEnv = {
-  ETHEREUM_SLOT_DURATION: 12,
-  AZTEC_SLOT_DURATION: 72,
-  AZTEC_EPOCH_DURATION: 32,
-  AZTEC_TARGET_COMMITTEE_SIZE: 48,
-  AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET: 2,
-  AZTEC_LAG_IN_EPOCHS_FOR_RANDAO: 2,
-  AZTEC_ACTIVATION_THRESHOLD: 100000000000000000000,
-  AZTEC_EJECTION_THRESHOLD: 50000000000000000000,
-  AZTEC_LOCAL_EJECTION_THRESHOLD: 98000000000000000000,
-  AZTEC_EXIT_DELAY_SECONDS: 172800,
-  AZTEC_INBOX_LAG: 2,
-  AZTEC_PROOF_SUBMISSION_EPOCHS: 1,
-  AZTEC_MANA_TARGET: 100000000,
-  AZTEC_PROVING_COST_PER_MANA: 100,
-  AZTEC_INITIAL_ETH_PER_FEE_ASSET: 10000000,
-  AZTEC_SLASHER_ENABLED: true,
-  AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS: 4,
-  AZTEC_SLASHING_LIFETIME_IN_ROUNDS: 5,
-  AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS: 0,
-  AZTEC_SLASHING_OFFSET_IN_ROUNDS: 2,
-  AZTEC_SLASHING_VETOER: '0x0000000000000000000000000000000000000000',
-  AZTEC_SLASHING_DISABLE_DURATION: 432000,
-  AZTEC_SLASH_AMOUNT_SMALL: 10000000000000000000,
-  AZTEC_SLASH_AMOUNT_MEDIUM: 20000000000000000000,
-  AZTEC_SLASH_AMOUNT_LARGE: 50000000000000000000,
-  AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE: 300,
-} as const;