@aztec/sequencer-client 0.68.1 → 0.69.0-devnet

package/src/publisher/l1-publisher.ts

@@ -16,24 +16,18 @@ import {
   type Proof,
 } from '@aztec/circuits.js';
 import { type FeeRecipient, type RootRollupPublicInputs } from '@aztec/circuits.js/rollup';
-import {
-  type EthereumChain,
-  type L1ContractsConfig,
-  L1TxUtils,
-  type L1TxUtilsConfig,
-  createEthereumChain,
-} from '@aztec/ethereum';
+import { type EthereumChain, type L1ContractsConfig, L1TxUtils, createEthereumChain } from '@aztec/ethereum';
 import { makeTuple } from '@aztec/foundation/array';
 import { toHex } from '@aztec/foundation/bigint-buffer';
 import { Blob } from '@aztec/foundation/blob';
 import { areArraysEqual, compactArray, times } from '@aztec/foundation/collection';
 import { type Signature } from '@aztec/foundation/eth-signature';
 import { Fr } from '@aztec/foundation/fields';
-import { createLogger } from '@aztec/foundation/log';
+import { type Logger, createLogger } from '@aztec/foundation/log';
 import { type Tuple, serializeToBuffer } from '@aztec/foundation/serialize';
 import { InterruptibleSleep } from '@aztec/foundation/sleep';
 import { Timer } from '@aztec/foundation/timer';
-import { ExtRollupLibAbi, GovernanceProposerAbi, LeonidasLibAbi, RollupAbi } from '@aztec/l1-artifacts';
+import { EmpireBaseAbi, ExtRollupLibAbi, LeonidasLibAbi, RollupAbi, SlasherAbi } from '@aztec/l1-artifacts';
 import { type TelemetryClient } from '@aztec/telemetry-client';
 
 import pick from 'lodash.pick';
@@ -135,6 +129,13 @@ export type L1SubmitEpochProofArgs = {
   proof: Proof;
 };
 
+export enum VoteType {
+  GOVERNANCE,
+  SLASHING,
+}
+
+type GetSlashPayloadCallBack = (slotNumber: bigint) => Promise<EthAddress | undefined>;
+
 /**
  * Publishes L2 blocks to L1. This implementation does *not* retry a transaction in
  * the event of network congestion, but should work for local development.
@@ -149,20 +150,25 @@ export class L1Publisher {
   private interrupted = false;
   private metrics: L1PublisherMetrics;
 
-  private payload: EthAddress = EthAddress.ZERO;
-  private myLastVote: bigint = 0n;
+  protected governanceLog = createLogger('sequencer:publisher:governance');
+  protected governanceProposerAddress?: EthAddress;
+  private governancePayload: EthAddress = EthAddress.ZERO;
+
+  protected slashingLog = createLogger('sequencer:publisher:slashing');
+  protected slashingProposerAddress?: EthAddress;
+  private getSlashPayload?: GetSlashPayloadCallBack = undefined;
+
+  private myLastVotes: Record<VoteType, bigint> = {
+    [VoteType.GOVERNANCE]: 0n,
+    [VoteType.SLASHING]: 0n,
+  };
 
   protected log = createLogger('sequencer:publisher');
-  protected governanceLog = createLogger('sequencer:publisher:governance');
 
   protected rollupContract: GetContractReturnType<
     typeof RollupAbi,
     WalletClient<HttpTransport, Chain, PrivateKeyAccount>
   >;
-  protected governanceProposerContract?: GetContractReturnType<
-    typeof GovernanceProposerAbi,
-    WalletClient<HttpTransport, Chain, PrivateKeyAccount>
-  > = undefined;
 
   protected publicClient: PublicClient<HttpTransport, Chain>;
   protected walletClient: WalletClient<HttpTransport, Chain, PrivateKeyAccount>;
@@ -178,7 +184,7 @@ export class L1Publisher {
   private readonly l1TxUtils: L1TxUtils;
 
   constructor(
-    config: TxSenderConfig & PublisherConfig & Pick<L1ContractsConfig, 'ethereumSlotDuration'> & L1TxUtilsConfig,
+    config: TxSenderConfig & PublisherConfig & Pick<L1ContractsConfig, 'ethereumSlotDuration'>,
     client: TelemetryClient,
   ) {
     this.sleepTimeMs = config?.l1PublishRetryIntervalMS ?? 60_000;
@@ -205,16 +211,31 @@ export class L1Publisher {
     });
 
     if (l1Contracts.governanceProposerAddress) {
-      this.governanceProposerContract = getContract({
-        address: getAddress(l1Contracts.governanceProposerAddress.toString()),
-        abi: GovernanceProposerAbi,
-        client: this.walletClient,
-      });
+      this.governanceProposerAddress = EthAddress.fromString(l1Contracts.governanceProposerAddress.toString());
     }
 
     this.l1TxUtils = new L1TxUtils(this.publicClient, this.walletClient, this.log, config);
   }
 
+  public registerSlashPayloadGetter(callback: GetSlashPayloadCallBack) {
+    this.getSlashPayload = callback;
+  }
+
+  private async getSlashingProposerAddress() {
+    if (this.slashingProposerAddress) {
+      return this.slashingProposerAddress;
+    }
+
+    const slasherAddress = await this.rollupContract.read.SLASHER();
+    const slasher = getContract({
+      address: getAddress(slasherAddress.toString()),
+      abi: SlasherAbi,
+      client: this.walletClient,
+    });
+    this.slashingProposerAddress = EthAddress.fromString(await slasher.read.PROPOSER());
+    return this.slashingProposerAddress;
+  }
+
   get publisherAddress() {
     return this.account.address;
   }
@@ -230,12 +251,12 @@ export class L1Publisher {
     });
   }
 
-  public getPayLoad() {
-    return this.payload;
+  public getGovernancePayload() {
+    return this.governancePayload;
   }
 
-  public setPayload(payload: EthAddress) {
-    this.payload = payload;
+  public setGovernancePayload(payload: EthAddress) {
+    this.governancePayload = payload;
   }
 
   public getSenderAddress(): EthAddress {
@@ -450,68 +471,106 @@ export class L1Publisher {
       calldataGas: getCalldataGasUsage(calldata),
     };
   }
-
-  public async castVote(slotNumber: bigint, timestamp: bigint): Promise<boolean> {
-    if (this.payload.equals(EthAddress.ZERO)) {
+  public async castVote(slotNumber: bigint, timestamp: bigint, voteType: VoteType) {
+    // @todo This function can be optimized by doing some of the computations locally instead of calling the L1 contracts
+    if (this.myLastVotes[voteType] >= slotNumber) {
       return false;
     }
 
-    if (!this.governanceProposerContract) {
-      return false;
-    }
+    const voteConfig = async (): Promise<
+      { payload: EthAddress; voteContractAddress: EthAddress; logger: Logger } | undefined
+    > => {
+      if (voteType === VoteType.GOVERNANCE) {
+        if (this.governancePayload.equals(EthAddress.ZERO)) {
+          return undefined;
+        }
+        if (!this.governanceProposerAddress) {
+          return undefined;
+        }
+        return {
+          payload: this.governancePayload,
+          voteContractAddress: this.governanceProposerAddress,
+          logger: this.governanceLog,
+        };
+      } else if (voteType === VoteType.SLASHING) {
+        if (!this.getSlashPayload) {
+          return undefined;
+        }
+        const slashingProposerAddress = await this.getSlashingProposerAddress();
+        if (!slashingProposerAddress) {
+          return undefined;
+        }
+
+        const slashPayload = await this.getSlashPayload(slotNumber);
+
+        if (!slashPayload) {
+          return undefined;
+        }
+
+        return {
+          payload: slashPayload,
+          voteContractAddress: slashingProposerAddress,
+          logger: this.slashingLog,
+        };
+      } else {
+        throw new Error('Invalid vote type');
+      }
+    };
 
-    if (this.myLastVote >= slotNumber) {
+    const vConfig = await voteConfig();
+
+    if (!vConfig) {
       return false;
     }
 
-    // @todo This can be optimized A LOT by doing the computation instead of making calls to L1, but it is  very convenient
-    // for when we keep changing the values and don't want to have multiple versions of the same logic implemented.
+    const { payload, voteContractAddress, logger } = vConfig;
+
+    const voteContract = getContract({
+      address: getAddress(voteContractAddress.toString()),
+      abi: EmpireBaseAbi,
+      client: this.walletClient,
+    });
 
     const [proposer, roundNumber] = await Promise.all([
       this.rollupContract.read.getProposerAt([timestamp]),
-      this.governanceProposerContract.read.computeRound([slotNumber]),
+      voteContract.read.computeRound([slotNumber]),
     ]);
 
     if (proposer.toLowerCase() !== this.account.address.toLowerCase()) {
       return false;
     }
 
-    const [slotForLastVote] = await this.governanceProposerContract.read.rounds([
-      this.rollupContract.address,
-      roundNumber,
-    ]);
+    const [slotForLastVote] = await voteContract.read.rounds([this.rollupContract.address, roundNumber]);
 
     if (slotForLastVote >= slotNumber) {
       return false;
     }
 
-    // Storing these early such that a quick entry again would not send another tx,
-    // revert the state if there is a failure.
-    const cachedMyLastVote = this.myLastVote;
-    this.myLastVote = slotNumber;
-
-    this.governanceLog.verbose(`Casting vote for ${this.payload}`);
+    const cachedMyLastVote = this.myLastVotes[voteType];
+    this.myLastVotes[voteType] = slotNumber;
 
     let txHash;
     try {
-      txHash = await this.governanceProposerContract.write.vote([this.payload.toString()], { account: this.account });
+      txHash = await voteContract.write.vote([payload.toString()], {
+        account: this.account,
+      });
     } catch (err) {
       const msg = prettyLogViemErrorMsg(err);
-      this.governanceLog.error(`Failed to vote`, msg);
-      this.myLastVote = cachedMyLastVote;
+      logger.error(`Failed to vote`, msg);
+      this.myLastVotes[voteType] = cachedMyLastVote;
       return false;
     }
 
     if (txHash) {
       const receipt = await this.getTransactionReceipt(txHash);
       if (!receipt) {
-        this.governanceLog.warn(`Failed to get receipt for tx ${txHash}`);
-        this.myLastVote = cachedMyLastVote;
+        logger.warn(`Failed to get receipt for tx ${txHash}`);
+        this.myLastVotes[voteType] = cachedMyLastVote;
         return false;
       }
     }
 
-    this.governanceLog.info(`Cast vote for ${this.payload}`);
+    logger.info(`Cast vote for ${payload}`);
     return true;
   }
 

package/src/sequencer/sequencer.ts

@@ -36,8 +36,9 @@ import { Attributes, type TelemetryClient, type Tracer, trackSpan } from '@aztec
 import { type ValidatorClient } from '@aztec/validator-client';
 
 import { type GlobalVariableBuilder } from '../global_variable_builder/global_builder.js';
-import { type L1Publisher } from '../publisher/l1-publisher.js';
+import { type L1Publisher, VoteType } from '../publisher/l1-publisher.js';
 import { prettyLogViemErrorMsg } from '../publisher/utils.js';
+import { type SlasherClient } from '../slasher/slasher_client.js';
 import { type TxValidatorFactory } from '../tx_validator/tx_validator_factory.js';
 import { getDefaultAllowedSetupFunctions } from './allowed.js';
 import { type SequencerConfig } from './config.js';
@@ -60,7 +61,7 @@ export class SequencerTooSlowError extends Error {
     public readonly currentTime: number,
   ) {
     super(
-      `Too far into slot to transition to ${proposedState}. max allowed: ${maxAllowedTime}s, time into slot: ${currentTime}s`,
+      `Too far into slot to transition to ${proposedState} (max allowed: ${maxAllowedTime}s, time into slot: ${currentTime}s)`,
     );
     this.name = 'SequencerTooSlowError';
   }
@@ -106,6 +107,7 @@ export class Sequencer {
     private globalsBuilder: GlobalVariableBuilder,
     private p2pClient: P2P,
     private worldState: WorldStateSynchronizer,
+    private slasherClient: SlasherClient,
     private blockBuilderFactory: BlockBuilderFactory,
     private l2BlockSource: L2BlockSource,
     private l1ToL2MessageSource: L1ToL2MessageSource,
@@ -122,6 +124,9 @@ export class Sequencer {
 
     // Register the block builder with the validator client for re-execution
     this.validatorClient?.registerBlockBuilder(this.buildBlock.bind(this));
+
+    // Register the slasher on the publisher to fetch slashing payloads
+    this.publisher.registerSlashPayloadGetter(this.slasherClient.getSlashPayload.bind(this.slasherClient));
   }
 
   get tracer(): Tracer {
@@ -157,7 +162,7 @@ export class Sequencer {
       this.maxBlockSizeInBytes = config.maxBlockSizeInBytes;
     }
     if (config.governanceProposerPayload) {
-      this.publisher.setPayload(config.governanceProposerPayload);
+      this.publisher.setGovernancePayload(config.governanceProposerPayload);
     }
     if (config.maxL1TxInclusionTimeIntoSlot !== undefined) {
       this.maxL1TxInclusionTimeIntoSlot = config.maxL1TxInclusionTimeIntoSlot;
@@ -172,10 +177,10 @@ export class Sequencer {
 
   private setTimeTable() {
     // How late into the slot can we be to start working
-    const initialTime = 1;
+    const initialTime = 2;
 
     // How long it takes to validate the txs collected and get ready to start building
-    const blockPrepareTime = 2;
+    const blockPrepareTime = 1;
 
     // How long it takes to for attestations to travel across the p2p layer.
     const attestationPropagationTime = 2;
@@ -245,6 +250,7 @@ export class Sequencer {
     this.log.debug(`Stopping sequencer`);
     await this.validatorClient?.stop();
     await this.runningPromise?.stop();
+    await this.slasherClient?.stop();
     this.publisher.interrupt();
     this.setState(SequencerState.STOPPED, 0n, true /** force */);
     this.log.info('Stopped sequencer');
@@ -314,7 +320,8 @@ export class Sequencer {
       slot,
     );
 
-    void this.publisher.castVote(slot, newGlobalVariables.timestamp.toBigInt());
+    void this.publisher.castVote(slot, newGlobalVariables.timestamp.toBigInt(), VoteType.GOVERNANCE);
+    void this.publisher.castVote(slot, newGlobalVariables.timestamp.toBigInt(), VoteType.SLASHING);
 
     if (!this.shouldProposeBlock(historicalHeader, {})) {
       return;
@@ -430,7 +437,7 @@ export class Sequencer {
     const bufferSeconds = maxAllowedTime - secondsIntoSlot;
 
     if (bufferSeconds < 0) {
-      this.log.warn(`Too far into slot to transition to ${proposedState}`, { maxAllowedTime, secondsIntoSlot });
+      this.log.debug(`Too far into slot to transition to ${proposedState}`, { maxAllowedTime, secondsIntoSlot });
       return false;
     }
 

package/src/slasher/factory.ts

@@ -0,0 +1,22 @@
+import type { L2BlockSource } from '@aztec/circuit-types';
+import { type L1ContractsConfig, type L1ReaderConfig } from '@aztec/ethereum';
+import { createLogger } from '@aztec/foundation/log';
+import { type AztecKVStore } from '@aztec/kv-store';
+import { type DataStoreConfig } from '@aztec/kv-store/config';
+import { createStore } from '@aztec/kv-store/lmdb';
+import { type TelemetryClient } from '@aztec/telemetry-client';
+import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
+
+import { SlasherClient } from './slasher_client.js';
+import { type SlasherConfig } from './slasher_client.js';
+
+export const createSlasherClient = async (
+  _config: SlasherConfig & DataStoreConfig & L1ContractsConfig & L1ReaderConfig,
+  l2BlockSource: L2BlockSource,
+  telemetry: TelemetryClient = new NoopTelemetryClient(),
+  deps: { store?: AztecKVStore } = {},
+) => {
+  const config = { ..._config };
+  const store = deps.store ?? (await createStore('slasher', config, createLogger('slasher:lmdb')));
+  return new SlasherClient(config, store, l2BlockSource, telemetry);
+};

package/src/slasher/index.ts

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