@aztec/ethereum 0.0.1-commit.9b94fc1 → 0.0.1-commit.9ee6fcc6

package/src/contracts/governance_proposer.ts

@@ -62,11 +62,16 @@ export class GovernanceProposerContract implements IEmpireBase {
   public async getRoundInfo(
     rollupAddress: Hex,
     round: bigint,
-  ): Promise<{ lastSignalSlot: SlotNumber; payloadWithMostSignals: Hex; executed: boolean }> {
+  ): Promise<{ lastSignalSlot: SlotNumber; payloadWithMostSignals: Hex; quorumReached: boolean; executed: boolean }> {
     const result = await this.proposer.read.getRoundData([rollupAddress, round]);
+    const [signalCount, quorum] = await Promise.all([
+      this.proposer.read.signalCount([rollupAddress, round, result.payloadWithMostSignals]),
+      this.getQuorumSize(),
+    ]);
     return {
       lastSignalSlot: SlotNumber.fromBigInt(result.lastSignalSlot),
       payloadWithMostSignals: result.payloadWithMostSignals,
+      quorumReached: signalCount >= quorum,
       executed: result.executed,
     };
   }
@@ -78,6 +83,7 @@ export class GovernanceProposerContract implements IEmpireBase {
   public createSignalRequest(payload: Hex): L1TxRequest {
     return {
       to: this.address.toString(),
+      abi: GovernanceProposerAbi,
       data: encodeSignal(payload),
     };
   }
@@ -99,10 +105,17 @@ export class GovernanceProposerContract implements IEmpireBase {
     );
     return {
       to: this.address.toString(),
+      abi: GovernanceProposerAbi,
       data: encodeSignalWithSignature(payload, signature),
     };
   }
 
+  /** Checks if a payload was ever submitted to governance via submitRoundWinner. */
+  public async hasPayloadBeenProposed(payload: Hex, fromBlock: bigint): Promise<boolean> {
+    const events = await this.proposer.getEvents.PayloadSubmitted({ payload }, { fromBlock, strict: true });
+    return events.length > 0;
+  }
+
   public async submitRoundWinner(
     round: bigint,
     l1TxUtils: L1TxUtils,
@@ -112,8 +125,9 @@ export class GovernanceProposerContract implements IEmpireBase {
   }> {
     const { receipt } = await l1TxUtils.sendAndMonitorTransaction({
       to: this.address.toString(),
+      abi: GovernanceProposerAbi,
       data: encodeFunctionData({
-        abi: this.proposer.abi,
+        abi: GovernanceProposerAbi,
         functionName: 'submitRoundWinner',
         args: [round],
       }),

package/src/contracts/inbox.ts

@@ -1,19 +1,33 @@
-import { Buffer16 } from '@aztec/foundation/buffer';
+import { CheckpointNumber } from '@aztec/foundation/branded-types';
+import { Buffer16, Buffer32 } from '@aztec/foundation/buffer';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { InboxAbi } from '@aztec/l1-artifacts/InboxAbi';
 
 import { type BlockTag, type GetContractReturnType, type Hex, getContract } from 'viem';
 
 import { getPublicClient } from '../client.js';
-import type { DeployL1ContractsReturnType } from '../deploy_l1_contracts.js';
+import type { DeployAztecL1ContractsReturnType } from '../deploy_aztec_l1_contracts.js';
 import type { L1ReaderConfig } from '../l1_reader.js';
 import type { ViemClient } from '../types.js';
+import type { L1EventLog } from './log.js';
 import { checkBlockTag } from './utils.js';
 
+/** Arguments for the MessageSent event. */
+export type MessageSentArgs = {
+  index: bigint;
+  leaf: Fr;
+  checkpointNumber: CheckpointNumber;
+  rollingHash: Buffer16;
+};
+
+/** Log type for MessageSent events. */
+export type MessageSentLog = L1EventLog<MessageSentArgs>;
+
 export class InboxContract {
   private readonly inbox: GetContractReturnType<typeof InboxAbi, ViemClient>;
 
-  static getFromL1ContractsValues(deployL1ContractsValues: DeployL1ContractsReturnType) {
+  static getFromL1ContractsValues(deployL1ContractsValues: DeployAztecL1ContractsReturnType) {
     const {
       l1Client,
       l1ContractAddresses: { inboxAddress },
@@ -45,6 +59,11 @@ export class InboxContract {
     return this.inbox;
   }
 
+  public async getLag(opts: { blockTag?: BlockTag; blockNumber?: bigint } = {}): Promise<bigint> {
+    await checkBlockTag(opts.blockNumber, this.client);
+    return await this.inbox.read.LAG(opts);
+  }
+
   public async getState(opts: { blockTag?: BlockTag; blockNumber?: bigint } = {}): Promise<InboxContractState> {
     await checkBlockTag(opts.blockNumber, this.client);
     const state = await this.inbox.read.getState(opts);
@@ -54,6 +73,39 @@ export class InboxContract {
       treeInProgress: state.inProgress,
     };
   }
+
+  /** Fetches MessageSent events within the given block range. */
+  async getMessageSentEvents(fromBlock: bigint, toBlock: bigint): Promise<MessageSentLog[]> {
+    const logs = await this.inbox.getEvents.MessageSent({}, { fromBlock, toBlock });
+    return logs
+      .filter(log => log.blockNumber! >= fromBlock && log.blockNumber! <= toBlock)
+      .map(log => this.mapMessageSentLog(log));
+  }
+
+  /** Fetches MessageSent events for a specific message hash within the given block range. */
+  async getMessageSentEventByHash(hash: Hex, fromBlock: bigint, toBlock: bigint): Promise<MessageSentLog[]> {
+    const logs = await this.inbox.getEvents.MessageSent({ hash }, { fromBlock, toBlock });
+    return logs.map(log => this.mapMessageSentLog(log));
+  }
+
+  private mapMessageSentLog(log: {
+    blockNumber: bigint | null;
+    blockHash: `0x${string}` | null;
+    transactionHash: `0x${string}` | null;
+    args: { index?: bigint; hash?: `0x${string}`; checkpointNumber?: bigint; rollingHash?: `0x${string}` };
+  }): MessageSentLog {
+    return {
+      l1BlockNumber: log.blockNumber!,
+      l1BlockHash: Buffer32.fromString(log.blockHash!),
+      l1TransactionHash: log.transactionHash!,
+      args: {
+        index: log.args.index!,
+        leaf: Fr.fromString(log.args.hash!),
+        checkpointNumber: CheckpointNumber.fromBigInt(log.args.checkpointNumber!),
+        rollingHash: Buffer16.fromString(log.args.rollingHash!),
+      },
+    };
+  }
 }
 
 export type InboxContractState = {

package/src/contracts/index.ts

@@ -1,12 +1,15 @@
 export * from './empire_base.js';
 export * from './errors.js';
 export * from './fee_asset_handler.js';
+export * from './fee_asset_price_oracle.js';
 export * from './fee_juice.js';
 export * from './governance.js';
 export * from './governance_proposer.js';
 export * from './gse.js';
 export * from './inbox.js';
+export * from './log.js';
 export * from './multicall.js';
+export * from './outbox.js';
 export * from './registry.js';
 export * from './rollup.js';
 export * from './empire_slashing_proposer.js';

package/src/contracts/log.ts

@@ -0,0 +1,13 @@
+import type { Buffer32 } from '@aztec/foundation/buffer';
+
+/** Base L1 event log with common fields. */
+export type L1EventLog<T> = {
+  /** L1 block number where the event was emitted. */
+  l1BlockNumber: bigint;
+  /** L1 block hash. */
+  l1BlockHash: Buffer32;
+  /** L1 transaction hash that emitted the event. */
+  l1TransactionHash: `0x${string}`;
+  /** Event-specific arguments. */
+  args: T;
+};

package/src/contracts/multicall.ts

@@ -2,7 +2,7 @@ import { toHex as toPaddedHex } from '@aztec/foundation/bigint-buffer';
 import { TimeoutError } from '@aztec/foundation/error';
 import type { Logger } from '@aztec/foundation/log';
 
-import { type EncodeFunctionDataParameters, type Hex, encodeFunctionData, multicall3Abi } from 'viem';
+import { type Address, type EncodeFunctionDataParameters, type Hex, encodeFunctionData, multicall3Abi } from 'viem';
 
 import type { L1BlobInputs, L1TxConfig, L1TxRequest, L1TxUtils } from '../l1_tx_utils/index.js';
 import type { ExtendedViemWalletClient } from '../types.js';
@@ -11,6 +11,39 @@ import { RollupContract } from './rollup.js';
 
 export const MULTI_CALL_3_ADDRESS = '0xcA11bde05977b3631167028862bE2a173976CA11' as const;
 
+/** ABI fragment for aggregate3Value — not included in viem's multicall3Abi. */
+export const aggregate3ValueAbi = [
+  {
+    inputs: [
+      {
+        components: [
+          { internalType: 'address', name: 'target', type: 'address' },
+          { internalType: 'bool', name: 'allowFailure', type: 'bool' },
+          { internalType: 'uint256', name: 'value', type: 'uint256' },
+          { internalType: 'bytes', name: 'callData', type: 'bytes' },
+        ],
+        internalType: 'struct Multicall3.Call3Value[]',
+        name: 'calls',
+        type: 'tuple[]',
+      },
+    ],
+    name: 'aggregate3Value',
+    outputs: [
+      {
+        components: [
+          { internalType: 'bool', name: 'success', type: 'bool' },
+          { internalType: 'bytes', name: 'returnData', type: 'bytes' },
+        ],
+        internalType: 'struct Multicall3.Result[]',
+        name: 'returnData',
+        type: 'tuple[]',
+      },
+    ],
+    stateMutability: 'payable',
+    type: 'function',
+  },
+] as const;
+
 export class Multicall3 {
   static async forward(
     requests: L1TxRequest[],
@@ -34,10 +67,13 @@ export class Multicall3 {
     };
 
     const encodedForwarderData = encodeFunctionData(forwarderFunctionData);
-
     try {
       const { receipt, state } = await l1TxUtils.sendAndMonitorTransaction(
-        { to: MULTI_CALL_3_ADDRESS, data: encodedForwarderData },
+        {
+          to: MULTI_CALL_3_ADDRESS,
+          data: encodedForwarderData,
+          abi: multicall3Abi,
+        },
         gasConfig,
         blobConfig,
       );
@@ -119,6 +155,37 @@ export class Multicall3 {
       throw err;
     }
   }
+
+  /** Batch multiple value transfers into a single aggregate3Value call on Multicall3. */
+  static async forwardValue(calls: { to: Address; value: bigint }[], l1TxUtils: L1TxUtils, logger: Logger) {
+    const args = calls.map(c => ({
+      target: c.to,
+      allowFailure: false,
+      value: c.value,
+      callData: '0x' as Hex,
+    }));
+
+    const data = encodeFunctionData({
+      abi: aggregate3ValueAbi,
+      functionName: 'aggregate3Value',
+      args: [args],
+    });
+
+    const totalValue = calls.reduce((sum, c) => sum + c.value, 0n);
+
+    logger.info(`Sending aggregate3Value with ${calls.length} calls`, { totalValue });
+    const { receipt } = await l1TxUtils.sendAndMonitorTransaction({
+      to: MULTI_CALL_3_ADDRESS,
+      data,
+      value: totalValue,
+    });
+
+    if (receipt.status !== 'success') {
+      throw new Error(`aggregate3Value transaction reverted: ${receipt.transactionHash}`);
+    }
+
+    return { receipt };
+  }
 }
 
 export async function deployMulticall3(l1Client: ExtendedViemWalletClient, logger: Logger) {

package/src/contracts/outbox.ts

@@ -0,0 +1,98 @@
+import type { EpochNumber } from '@aztec/foundation/branded-types';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { OutboxAbi } from '@aztec/l1-artifacts/OutboxAbi';
+
+import { type GetContractReturnType, type Hex, encodeAbiParameters, getContract, hexToBigInt, keccak256 } from 'viem';
+
+import { getPublicClient } from '../client.js';
+import type { DeployAztecL1ContractsReturnType } from '../deploy_aztec_l1_contracts.js';
+import type { L1ReaderConfig } from '../l1_reader.js';
+import { type ExtendedViemWalletClient, type ViemClient, isExtendedClient } from '../types.js';
+
+export type ViemL1Actor = {
+  actor: Hex;
+  chainId: bigint;
+};
+
+export type ViemL2Actor = {
+  actor: Hex;
+  version: bigint;
+};
+
+export type ViemL2ToL1Msg = {
+  sender: ViemL2Actor;
+  recipient: ViemL1Actor;
+  content: Hex;
+};
+
+export class OutboxContract {
+  private readonly outbox: GetContractReturnType<typeof OutboxAbi, ViemClient>;
+
+  static getFromL1ContractsValues(deployL1ContractsValues: DeployAztecL1ContractsReturnType) {
+    const {
+      l1Client,
+      l1ContractAddresses: { outboxAddress },
+    } = deployL1ContractsValues;
+    return new OutboxContract(l1Client, outboxAddress.toString());
+  }
+
+  static getFromConfig(config: L1ReaderConfig) {
+    const client = getPublicClient(config);
+    const address = config.l1Contracts.outboxAddress.toString();
+    return new OutboxContract(client, address);
+  }
+
+  static getEpochRootStorageSlot(epoch: EpochNumber) {
+    return hexToBigInt(keccak256(encodeAbiParameters([{ type: 'uint256' }, { type: 'uint256' }], [BigInt(epoch), 0n])));
+  }
+
+  constructor(
+    public readonly client: ViemClient,
+    address: Hex | EthAddress,
+  ) {
+    if (address instanceof EthAddress) {
+      address = address.toString();
+    }
+    this.outbox = getContract({ address, abi: OutboxAbi, client });
+  }
+
+  public get address() {
+    return this.outbox.address;
+  }
+
+  public getContract(): GetContractReturnType<typeof OutboxAbi, ViemClient> {
+    return this.outbox;
+  }
+
+  public hasMessageBeenConsumedAtEpoch(epoch: EpochNumber, leafId: bigint) {
+    return this.outbox.read.hasMessageBeenConsumedAtEpoch([BigInt(epoch), leafId]);
+  }
+
+  public getRootData(epoch: EpochNumber) {
+    return this.outbox.read.getRootData([BigInt(epoch)]);
+  }
+
+  public consume(message: ViemL2ToL1Msg, epoch: EpochNumber, leafIndex: bigint, path: Hex[]) {
+    const wallet = this.assertWallet();
+    return wallet.write.consume([message, BigInt(epoch), leafIndex, path]);
+  }
+
+  public async getMessageConsumedEvents(
+    l1BlockHash: Hex,
+  ): Promise<{ epoch: bigint; root: Hex; messageHash: Hex; leafId: bigint }[]> {
+    const events = await this.outbox.getEvents.MessageConsumed({}, { blockHash: l1BlockHash, strict: true });
+    return events.map(event => ({
+      epoch: event.args.epoch!,
+      root: event.args.root!,
+      messageHash: event.args.messageHash!,
+      leafId: event.args.leafId!,
+    }));
+  }
+
+  private assertWallet(): GetContractReturnType<typeof OutboxAbi, ExtendedViemWalletClient> {
+    if (!isExtendedClient(this.client)) {
+      throw new Error('Wallet client is required for this operation');
+    }
+    return this.outbox as GetContractReturnType<typeof OutboxAbi, ExtendedViemWalletClient>;
+  }
+}

package/src/contracts/registry.ts

@@ -3,7 +3,7 @@ import { createLogger } from '@aztec/foundation/log';
 import { RegistryAbi } from '@aztec/l1-artifacts/RegistryAbi';
 import { TestERC20Abi } from '@aztec/l1-artifacts/TestERC20Abi';
 
-import { type GetContractReturnType, type Hex, getContract } from 'viem';
+import { type GetContractReturnType, type Hex, getAbiItem, getContract } from 'viem';
 
 import type { L1ContractAddresses } from '../l1_contract_addresses.js';
 import type { ViemClient } from '../types.js';
@@ -128,4 +128,34 @@ export class RegistryContract {
   public async getRewardDistributor(): Promise<EthAddress> {
     return EthAddress.fromString(await this.registry.read.getRewardDistributor());
   }
+
+  /** Returns the L1 timestamp at which the given rollup was registered via addRollup(). */
+  public async getCanonicalRollupRegistrationTimestamp(
+    rollupAddress: EthAddress,
+    fromBlock?: bigint,
+  ): Promise<bigint | undefined> {
+    const event = getAbiItem({ abi: RegistryAbi, name: 'CanonicalRollupUpdated' });
+    const start = fromBlock ?? 0n;
+    const latestBlock = await this.client.getBlockNumber();
+    const chunkSize = 1_000n;
+
+    for (let from = start; from <= latestBlock; from += chunkSize) {
+      const to = from + chunkSize - 1n > latestBlock ? latestBlock : from + chunkSize - 1n;
+      const logs = await this.client.getLogs({
+        address: this.address.toString(),
+        fromBlock: from,
+        toBlock: to,
+        strict: true,
+        event,
+        args: { instance: rollupAddress.toString() },
+      });
+
+      if (logs.length > 0) {
+        const block = await this.client.getBlock({ blockNumber: logs[0].blockNumber });
+        return block.timestamp;
+      }
+    }
+
+    return undefined;
+  }
 }