@aztec/ethereum 0.0.0-test.0 → 0.0.1-commit.0208eb9

package/src/publisher_manager.ts

@@ -0,0 +1,108 @@
+import { pick } from '@aztec/foundation/collection';
+import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
+
+import { L1TxUtils, TxUtilsState } from './l1_tx_utils/index.js';
+
+// Defines the order in which we prioritise publishers based on their state (first is better)
+const sortOrder = [
+  // Always prefer sending from idle publishers
+  TxUtilsState.IDLE,
+  // Then from publishers that have sent a tx and it got mined
+  TxUtilsState.MINED,
+  // Then from publishers that have sent a tx but it's in-flight
+  TxUtilsState.SPEED_UP,
+  TxUtilsState.SENT,
+  // We leave cancelled and not-mined states for last, since these represent failures to mines and could be problematic
+  TxUtilsState.CANCELLED,
+  TxUtilsState.NOT_MINED,
+];
+
+// Which states represent a busy publisher that we should avoid if possible
+const busyStates: TxUtilsState[] = [
+  TxUtilsState.SENT,
+  TxUtilsState.SPEED_UP,
+  TxUtilsState.CANCELLED,
+  TxUtilsState.NOT_MINED,
+];
+
+export type PublisherFilter<UtilsType extends L1TxUtils> = (utils: UtilsType) => boolean;
+
+export class PublisherManager<UtilsType extends L1TxUtils = L1TxUtils> {
+  private log: Logger;
+  private config: { publisherAllowInvalidStates?: boolean };
+
+  constructor(
+    private publishers: UtilsType[],
+    config: { publisherAllowInvalidStates?: boolean },
+    bindings?: LoggerBindings,
+  ) {
+    this.log = createLogger('publisher:manager', bindings);
+    this.log.info(`PublisherManager initialized with ${publishers.length} publishers.`);
+    this.publishers = publishers;
+    this.config = pick(config, 'publisherAllowInvalidStates');
+  }
+
+  /** Loads the state of all publishers and resumes monitoring any pending txs */
+  public async loadState(): Promise<void> {
+    await Promise.all(this.publishers.map(pub => pub.loadStateAndResumeMonitoring()));
+  }
+
+  // Finds and prioritises available publishers based on
+  // 1. Validity as per the provided filter function
+  // 2. Validity based on the state the publisher is in
+  // 3. Priority based on state as defined by sortOrder
+  // 4. Then priority based on highest balance
+  // 5. Then priority based on least recently used
+  public async getAvailablePublisher(filter: PublisherFilter<UtilsType> = () => true): Promise<UtilsType> {
+    this.log.debug(`Getting available publisher`, {
+      publishers: this.publishers.map(p => ({
+        address: p.getSenderAddress(),
+        state: p.state,
+        lastMined: p.lastMinedAtBlockNumber,
+      })),
+    });
+
+    // Extract the valid publishers
+    let validPublishers = this.publishers.filter((pub: UtilsType) => !busyStates.includes(pub.state) && filter(pub));
+
+    // If none found but we allow invalid (busy) states, try again including them
+    if (validPublishers.length === 0 && this.config.publisherAllowInvalidStates) {
+      this.log.warn(`No valid publishers found. Trying again including invalid states.`);
+      validPublishers = this.publishers.filter(pub => filter(pub));
+    }
+
+    // Error if none found
+    if (validPublishers.length === 0) {
+      throw new Error(`Failed to find an available publisher.`);
+    }
+
+    // Get the balances
+    const publishersWithBalance = await Promise.all(
+      validPublishers.map(async pub => {
+        return { balance: await pub.getSenderBalance(), publisher: pub };
+      }),
+    );
+
+    // Sort based on state, then balance, then time since last use
+    const sortedPublishers = publishersWithBalance.sort((a, b) => {
+      const stateComparison = sortOrder.indexOf(a.publisher.state) - sortOrder.indexOf(b.publisher.state);
+      if (stateComparison !== 0) {
+        return stateComparison;
+      }
+      const balanceComparison = Number(b.balance - a.balance);
+      if (balanceComparison !== 0) {
+        return balanceComparison;
+      }
+      const lastUsedComparison = Number(
+        (a.publisher.lastMinedAtBlockNumber ?? 0n) - (b.publisher.lastMinedAtBlockNumber ?? 0n),
+      );
+      return lastUsedComparison;
+    });
+
+    return sortedPublishers[0].publisher;
+  }
+
+  public interrupt() {
+    this.publishers.forEach(pub => pub.interrupt());
+  }
+}

package/src/queries.ts

@@ -1,7 +1,9 @@
-import type { EthAddress } from '@aztec/foundation/eth-address';
+import { EthAddress } from '@aztec/foundation/eth-address';
 
-import type { L1ContractsConfig } from './config.js';
-import { GovernanceContract } from './contracts/governance.js';
+import { DefaultL1ContractsConfig, type L1ContractsConfig } from './config.js';
+import { ReadOnlyGovernanceContract } from './contracts/governance.js';
+import { GovernanceProposerContract } from './contracts/governance_proposer.js';
+import { InboxContract } from './contracts/inbox.js';
 import { RollupContract } from './contracts/rollup.js';
 import type { ViemPublicClient } from './types.js';
 
@@ -9,50 +11,114 @@ import type { ViemPublicClient } from './types.js';
 export async function getL1ContractsConfig(
   publicClient: ViemPublicClient,
   addresses: { governanceAddress: EthAddress; rollupAddress?: EthAddress },
-): Promise<Omit<L1ContractsConfig, 'ethereumSlotDuration'> & { l1StartBlock: bigint; l1GenesisTime: bigint }> {
-  const governance = new GovernanceContract(addresses.governanceAddress.toString(), publicClient, undefined);
-  const governanceProposer = await governance.getProposer();
-  const rollupAddress = addresses.rollupAddress ?? (await governance.getGovernanceAddresses()).rollupAddress;
+): Promise<
+  Omit<L1ContractsConfig, 'ethereumSlotDuration'> & {
+    l1StartBlock: bigint;
+    l1GenesisTime: bigint;
+    rollupVersion: number;
+    genesisArchiveTreeRoot: `0x${string}`;
+  }
+> {
+  const governance = new ReadOnlyGovernanceContract(addresses.governanceAddress.toString(), publicClient);
+  const governanceProposerAddress = await governance.getGovernanceProposerAddress();
+  const governanceProposer = new GovernanceProposerContract(publicClient, governanceProposerAddress.toString());
+  const rollupAddress = addresses.rollupAddress ?? (await governanceProposer.getRollupAddress());
   const rollup = new RollupContract(publicClient, rollupAddress.toString());
   const slasherProposer = await rollup.getSlashingProposer();
+  const slasher = await rollup.getSlasherContract();
+  const rollupAddresses = await rollup.getRollupAddresses();
+  const inboxContract = new InboxContract(publicClient, rollupAddresses.inboxAddress.toString());
 
   const [
     l1StartBlock,
     l1GenesisTime,
     aztecEpochDuration,
-    aztecProofSubmissionWindow,
     aztecSlotDuration,
+    aztecProofSubmissionEpochs,
     aztecTargetCommitteeSize,
-    minimumStake,
+    lagInEpochsForValidatorSet,
+    lagInEpochsForRandao,
+    inboxLag,
+    activationThreshold,
+    ejectionThreshold,
+    localEjectionThreshold,
     governanceProposerQuorum,
     governanceProposerRoundSize,
     slashingQuorum,
     slashingRoundSize,
+    slashingLifetimeInRounds,
+    slashingExecutionDelayInRounds,
+    slashingOffsetInRounds,
+    slashingAmounts,
+    slashingVetoer,
+    slashingDisableDuration,
+    manaTarget,
+    provingCostPerMana,
+    rollupVersion,
+    genesisArchiveTreeRoot,
+    exitDelay,
   ] = await Promise.all([
     rollup.getL1StartBlock(),
     rollup.getL1GenesisTime(),
     rollup.getEpochDuration(),
-    rollup.getProofSubmissionWindow(),
     rollup.getSlotDuration(),
+    rollup.getProofSubmissionEpochs(),
     rollup.getTargetCommitteeSize(),
-    rollup.getMinimumStake(),
+    rollup.getLagInEpochsForValidatorSet(),
+    rollup.getLagInEpochsForRandao(),
+    inboxContract.getLag(),
+    rollup.getActivationThreshold(),
+    rollup.getEjectionThreshold(),
+    rollup.getLocalEjectionThreshold(),
     governanceProposer.getQuorumSize(),
     governanceProposer.getRoundSize(),
-    slasherProposer.getQuorumSize(),
-    slasherProposer.getRoundSize(),
+    slasherProposer?.getQuorumSize() ?? 0n,
+    slasherProposer?.getRoundSize() ?? 0n,
+    slasherProposer?.getLifetimeInRounds() ?? 0n,
+    slasherProposer?.getExecutionDelayInRounds() ?? 0n,
+    slasherProposer?.type === 'tally' ? slasherProposer.getSlashOffsetInRounds() : 0n,
+    slasherProposer?.type === 'tally' ? slasherProposer.getSlashingAmounts() : [0n, 0n, 0n],
+    slasher?.getVetoer() ?? EthAddress.ZERO,
+    slasher?.getSlashingDisableDuration() ?? 0,
+    rollup.getManaTarget(),
+    rollup.getProvingCostPerMana(),
+    rollup.getVersion(),
+    rollup.getGenesisArchiveTreeRoot(),
+    rollup.getExitDelay(),
   ] as const);
 
   return {
     l1StartBlock,
     l1GenesisTime,
     aztecEpochDuration: Number(aztecEpochDuration),
-    aztecProofSubmissionWindow: Number(aztecProofSubmissionWindow),
     aztecSlotDuration: Number(aztecSlotDuration),
+    aztecProofSubmissionEpochs: Number(aztecProofSubmissionEpochs),
     aztecTargetCommitteeSize: Number(aztecTargetCommitteeSize),
+    lagInEpochsForValidatorSet: Number(lagInEpochsForValidatorSet),
+    lagInEpochsForRandao: Number(lagInEpochsForRandao),
+    inboxLag: Number(inboxLag),
     governanceProposerQuorum: Number(governanceProposerQuorum),
     governanceProposerRoundSize: Number(governanceProposerRoundSize),
-    minimumStake,
+    governanceVotingDuration: DefaultL1ContractsConfig.governanceVotingDuration,
+    activationThreshold,
+    ejectionThreshold,
+    localEjectionThreshold,
     slashingQuorum: Number(slashingQuorum),
-    slashingRoundSize: Number(slashingRoundSize),
+    slashingRoundSizeInEpochs: Number(Number(slashingRoundSize) / aztecEpochDuration),
+    slashingLifetimeInRounds: Number(slashingLifetimeInRounds),
+    slashingExecutionDelayInRounds: Number(slashingExecutionDelayInRounds),
+    slashingVetoer,
+    slashingDisableDuration,
+    manaTarget,
+    provingCostPerMana: provingCostPerMana,
+    rollupVersion: Number(rollupVersion),
+    genesisArchiveTreeRoot: genesisArchiveTreeRoot.toString(),
+    exitDelaySeconds: Number(exitDelay),
+    slasherFlavor: slasherProposer?.type ?? 'tally',
+    slashingOffsetInRounds: Number(slashingOffsetInRounds),
+    slashAmountSmall: slashingAmounts[0],
+    slashAmountMedium: slashingAmounts[1],
+    slashAmountLarge: slashingAmounts[2],
+    initialEthPerFeeAsset: DefaultL1ContractsConfig.initialEthPerFeeAsset,
   };
 }

package/src/test/chain_monitor.ts

@@ -0,0 +1,245 @@
+import type { RollupContract } from '@aztec/ethereum/contracts';
+import { InboxContract } from '@aztec/ethereum/contracts';
+import { CheckpointNumber, EpochNumber, SlotNumber } from '@aztec/foundation/branded-types';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { createLogger } from '@aztec/foundation/log';
+import { promiseWithResolvers } from '@aztec/foundation/promise';
+import { DateProvider } from '@aztec/foundation/timer';
+
+import { EventEmitter } from 'events';
+
+import type { ViemClient } from '../types.js';
+
+export type ChainMonitorEventMap = {
+  'l1-block': [{ l1BlockNumber: number; timestamp: bigint }];
+  checkpoint: [
+    { checkpointNumber: CheckpointNumber; l1BlockNumber: number; l2SlotNumber: SlotNumber; timestamp: bigint },
+  ];
+  'checkpoint-proven': [{ provenCheckpointNumber: CheckpointNumber; l1BlockNumber: number; timestamp: bigint }];
+  'l2-messages': [{ totalL2Messages: number; l1BlockNumber: number }];
+  'l2-epoch': [{ l2EpochNumber: EpochNumber; timestamp: bigint; committee: EthAddress[] | undefined }];
+  'l2-slot': [{ l2SlotNumber: SlotNumber; timestamp: bigint }];
+};
+
+/** Utility class that polls the chain on quick intervals and logs new L1 blocks, L2 blocks, and L2 proofs. */
+export class ChainMonitor extends EventEmitter<ChainMonitorEventMap> {
+  private readonly l1Client: ViemClient;
+  private inbox: InboxContract | undefined;
+  private handle: NodeJS.Timeout | undefined;
+  // eslint-disable-next-line aztec-custom/no-non-primitive-in-collections
+  private running: Set<Promise<void>> = new Set();
+
+  /** Current L1 block number */
+  public l1BlockNumber!: number;
+  /** Current checkpoint number */
+  public checkpointNumber!: CheckpointNumber;
+  /** Current proven checkpoint number */
+  public provenCheckpointNumber!: CheckpointNumber;
+  /** L1 timestamp for the current checkpoint */
+  public checkpointTimestamp!: bigint;
+  /** L1 timestamp for the proven checkpoint */
+  public provenCheckpointTimestamp!: bigint;
+  /** Total number of L2 messages pushed into the Inbox */
+  public totalL2Messages: number = 0;
+  /** Current L2 epoch number */
+  public l2EpochNumber!: EpochNumber;
+  /** Current L2 slot number */
+  public l2SlotNumber!: SlotNumber;
+
+  constructor(
+    private readonly rollup: RollupContract,
+    private readonly dateProvider: DateProvider = new DateProvider(),
+    private readonly logger = createLogger('aztecjs:utils:chain_monitor'),
+    private readonly intervalMs = 200,
+  ) {
+    super();
+    this.l1Client = rollup.client;
+  }
+
+  start() {
+    if (this.handle) {
+      throw new Error('Chain monitor already started');
+    }
+    this.handle = setInterval(this.safeRun.bind(this), this.intervalMs);
+    return this;
+  }
+
+  async stop() {
+    try {
+      this.removeAllListeners();
+      if (this.handle) {
+        clearInterval(this.handle!);
+        this.handle = undefined;
+      }
+      await Promise.allSettled([...this.running]);
+    } catch (err) {
+      this.logger.error('Error stopping chain monitor', err);
+    }
+  }
+
+  private async getInbox() {
+    if (!this.inbox) {
+      const { inboxAddress } = await this.rollup.getRollupAddresses();
+      this.inbox = new InboxContract(this.l1Client, inboxAddress);
+    }
+    return this.inbox;
+  }
+
+  protected safeRun() {
+    const running = promiseWithResolvers<void>();
+    this.running.add(running.promise);
+
+    void this.run()
+      .catch(error => {
+        this.logger.error('Error in chain monitor loop', error);
+      })
+      .finally(() => {
+        running.resolve();
+        this.running.delete(running.promise);
+      });
+  }
+
+  async run(force = false) {
+    const newL1BlockNumber = Number(await this.l1Client.getBlockNumber({ cacheTime: 0 }));
+    if (!force && this.l1BlockNumber === newL1BlockNumber) {
+      return this;
+    }
+    this.l1BlockNumber = newL1BlockNumber;
+
+    const [l2SlotNumber, l2Epoch, l1block] = await Promise.all([
+      this.rollup.getSlotNumber(),
+      this.rollup.getCurrentEpoch(),
+      this.l1Client.getBlock({ blockNumber: BigInt(newL1BlockNumber), includeTransactions: false }),
+    ]);
+
+    const timestamp = l1block.timestamp;
+    const timestampString = new Date(Number(timestamp) * 1000).toTimeString().split(' ')[0];
+
+    this.emit('l1-block', { l1BlockNumber: newL1BlockNumber, timestamp });
+    let msg = `L1 block ${newL1BlockNumber} mined at ${timestampString}`;
+
+    const newCheckpointNumber = await this.rollup.getCheckpointNumber();
+    if (this.checkpointNumber !== newCheckpointNumber) {
+      const epochNumber = await this.rollup.getEpochNumberForCheckpoint(newCheckpointNumber);
+      msg += ` with new checkpoint ${newCheckpointNumber} for epoch ${epochNumber}`;
+      this.checkpointNumber = newCheckpointNumber;
+      this.checkpointTimestamp = timestamp;
+      this.emit('checkpoint', {
+        checkpointNumber: newCheckpointNumber,
+        l1BlockNumber: newL1BlockNumber,
+        l2SlotNumber,
+        timestamp,
+      });
+    }
+
+    const newProvenCheckpointNumber = await this.rollup.getProvenCheckpointNumber();
+    if (this.provenCheckpointNumber !== newProvenCheckpointNumber) {
+      const epochNumber = await this.rollup.getEpochNumberForCheckpoint(newProvenCheckpointNumber);
+      msg += ` with proof up to checkpoint ${newProvenCheckpointNumber} for epoch ${epochNumber}`;
+      this.provenCheckpointNumber = newProvenCheckpointNumber;
+      this.provenCheckpointTimestamp = timestamp;
+      this.emit('checkpoint-proven', {
+        provenCheckpointNumber: newProvenCheckpointNumber,
+        l1BlockNumber: newL1BlockNumber,
+        timestamp,
+      });
+    }
+
+    const inbox = await this.getInbox();
+    const newTotalL2Messages = await inbox.getState().then(s => Number(s.totalMessagesInserted));
+    if (this.totalL2Messages !== newTotalL2Messages) {
+      msg += ` with ${newTotalL2Messages - this.totalL2Messages} new L2 messages (total ${newTotalL2Messages})`;
+      this.totalL2Messages = newTotalL2Messages;
+      this.emit('l2-messages', { totalL2Messages: newTotalL2Messages, l1BlockNumber: newL1BlockNumber });
+    }
+
+    let committee: EthAddress[] | undefined;
+    if (l2Epoch !== this.l2EpochNumber) {
+      this.l2EpochNumber = l2Epoch;
+      committee = await this.rollup.getCurrentEpochCommittee();
+      this.emit('l2-epoch', { l2EpochNumber: l2Epoch, timestamp, committee });
+      msg += ` starting new epoch ${this.l2EpochNumber} `;
+    }
+
+    if (l2SlotNumber !== this.l2SlotNumber) {
+      this.l2SlotNumber = l2SlotNumber;
+      this.emit('l2-slot', { l2SlotNumber, timestamp });
+    }
+
+    this.logger.info(msg, {
+      currentTimestamp: this.dateProvider.nowInSeconds(),
+      l1Timestamp: timestamp,
+      l1BlockNumber: this.l1BlockNumber,
+      l2SlotNumber,
+      l2Epoch,
+      checkpointNumber: this.checkpointNumber,
+      provenCheckpointNumber: this.provenCheckpointNumber,
+      totalL2Messages: this.totalL2Messages,
+      committee,
+    });
+
+    return this;
+  }
+
+  public waitUntilL2Slot(slot: SlotNumber): Promise<void> {
+    if (this.l2SlotNumber >= slot) {
+      return Promise.resolve();
+    }
+    return new Promise(resolve => {
+      const listener = (data: { l2SlotNumber: SlotNumber; timestamp: bigint }) => {
+        if (data.l2SlotNumber >= slot) {
+          this.off('l2-slot', listener);
+          resolve();
+        }
+      };
+      this.on('l2-slot', listener);
+    });
+  }
+
+  public waitUntilL1Block(block: number | bigint): Promise<void> {
+    const targetBlock = typeof block === 'bigint' ? block.valueOf() : block;
+    if (this.l1BlockNumber >= targetBlock) {
+      return Promise.resolve();
+    }
+    return new Promise(resolve => {
+      const listener = (data: { l1BlockNumber: number; timestamp: bigint }) => {
+        if (data.l1BlockNumber >= targetBlock) {
+          this.off('l1-block', listener);
+          resolve();
+        }
+      };
+      this.on('l1-block', listener);
+    });
+  }
+
+  public waitUntilL1Timestamp(timestamp: number | bigint): Promise<void> {
+    const targetTimestamp = typeof timestamp === 'bigint' ? timestamp.valueOf() : timestamp;
+    if (this.l1BlockNumber >= targetTimestamp) {
+      return Promise.resolve();
+    }
+    return new Promise(resolve => {
+      const listener = (data: { l1BlockNumber: number; timestamp: bigint }) => {
+        if (data.timestamp >= targetTimestamp) {
+          this.off('l1-block', listener);
+          resolve();
+        }
+      };
+      this.on('l1-block', listener);
+    });
+  }
+
+  public waitUntilCheckpoint(checkpointNumber: CheckpointNumber): Promise<void> {
+    if (this.checkpointNumber >= checkpointNumber) {
+      return Promise.resolve();
+    }
+    return new Promise(resolve => {
+      const listener = (data: { checkpointNumber: CheckpointNumber; timestamp: bigint }) => {
+        if (data.checkpointNumber >= checkpointNumber) {
+          this.off('checkpoint', listener);
+          resolve();
+        }
+      };
+      this.on('checkpoint', listener);
+    });
+  }
+}

package/src/test/delayed_tx_utils.ts

@@ -1,24 +1,52 @@
-import { L1TxUtilsWithBlobs } from '../l1_tx_utils_with_blobs.js';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { type Logger, createLogger } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
+
+import { type L1TxUtilsConfig, createViemSigner } from '../l1_tx_utils/index.js';
+import { L1TxUtilsWithBlobs } from '../l1_tx_utils/l1_tx_utils_with_blobs.js';
+import type { ExtendedViemWalletClient } from '../types.js';
 import { type Delayer, withDelayer } from './tx_delayer.js';
 
 export class DelayedTxUtils extends L1TxUtilsWithBlobs {
   public delayer: Delayer | undefined;
 
-  public static fromL1TxUtils(l1TxUtils: L1TxUtilsWithBlobs, ethereumSlotDuration: number) {
-    const { client, delayer } = withDelayer(l1TxUtils.walletClient, {
+  public static fromL1TxUtils(
+    l1TxUtils: L1TxUtilsWithBlobs,
+    ethereumSlotDuration: number,
+    wallet: ExtendedViemWalletClient,
+  ) {
+    const { client, delayer } = withDelayer(wallet, l1TxUtils.dateProvider, {
       ethereumSlotDuration,
     });
     const casted = l1TxUtils as unknown as DelayedTxUtils;
     casted.delayer = delayer;
-    casted.walletClient = client;
+    casted.client = client;
     return casted;
   }
 
   public enableDelayer(ethereumSlotDuration: number) {
-    const { client, delayer } = withDelayer(this.walletClient, {
+    const { client, delayer } = withDelayer(this.client, this.dateProvider, {
       ethereumSlotDuration,
     });
     this.delayer = delayer;
-    this.walletClient = client;
+    this.client = client;
   }
 }
+
+export function createDelayedL1TxUtilsFromViemWallet(
+  client: ExtendedViemWalletClient,
+  logger: Logger = createLogger('L1TxUtils'),
+  dateProvider: DateProvider = new DateProvider(),
+  config?: Partial<L1TxUtilsConfig>,
+  debugMaxGasLimit: boolean = false,
+) {
+  return new DelayedTxUtils(
+    client,
+    EthAddress.fromString(client.account.address),
+    createViemSigner(client),
+    logger,
+    dateProvider,
+    config,
+    debugMaxGasLimit,
+  );
+}