@aztec/ethereum 0.72.1 → 0.74.0

package/src/contracts/rollup.ts

@@ -1,31 +1,89 @@
-import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { memoize } from '@aztec/foundation/decorators';
-import { RollupAbi } from '@aztec/l1-artifacts';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { ViemSignature } from '@aztec/foundation/eth-signature';
+import { RollupAbi, RollupStorage, SlasherAbi } from '@aztec/l1-artifacts';
 
 import {
+  type Account,
   type Chain,
   type GetContractReturnType,
   type Hex,
   type HttpTransport,
   type PublicClient,
   createPublicClient,
+  getAddress,
   getContract,
   http,
 } from 'viem';
 
+import { createEthereumChain } from '../chain.js';
 import { type DeployL1Contracts } from '../deploy_l1_contracts.js';
-import { createEthereumChain } from '../ethereum_chain.js';
+import { type L1ContractAddresses } from '../l1_contract_addresses.js';
 import { type L1ReaderConfig } from '../l1_reader.js';
+import { formatViemError } from '../utils.js';
+import { SlashingProposerContract } from './slashing_proposer.js';
+
+export type L1RollupContractAddresses = Pick<
+  L1ContractAddresses,
+  | 'rollupAddress'
+  | 'inboxAddress'
+  | 'outboxAddress'
+  | 'feeJuicePortalAddress'
+  | 'feeJuiceAddress'
+  | 'stakingAssetAddress'
+  | 'rewardDistributorAddress'
+>;
+
+export type EpochProofQuoteViemArgs = {
+  epochToProve: bigint;
+  validUntilSlot: bigint;
+  bondAmount: bigint;
+  prover: `0x${string}`;
+  basisPointFee: number;
+};
 
 export class RollupContract {
   private readonly rollup: GetContractReturnType<typeof RollupAbi, PublicClient<HttpTransport, Chain>>;
 
+  static get checkBlobStorageSlot(): bigint {
+    const asString = RollupStorage.find(storage => storage.label === 'checkBlob')?.slot;
+    if (asString === undefined) {
+      throw new Error('checkBlobStorageSlot not found');
+    }
+    return BigInt(asString);
+  }
+
+  static getFromL1ContractsValues(deployL1ContractsValues: DeployL1Contracts) {
+    const {
+      publicClient,
+      l1ContractAddresses: { rollupAddress },
+    } = deployL1ContractsValues;
+    return new RollupContract(publicClient, rollupAddress.toString());
+  }
+
+  static getFromConfig(config: L1ReaderConfig) {
+    const client = createPublicClient({
+      transport: http(config.l1RpcUrl),
+      chain: createEthereumChain(config.l1RpcUrl, config.l1ChainId).chainInfo,
+    });
+    const address = config.l1Contracts.rollupAddress.toString();
+    return new RollupContract(client, address);
+  }
+
   constructor(public readonly client: PublicClient<HttpTransport, Chain>, address: Hex) {
     this.rollup = getContract({ address, abi: RollupAbi, client });
   }
 
   public get address() {
-    return AztecAddress.fromString(this.rollup.address);
+    return this.rollup.address;
+  }
+
+  @memoize
+  public async getSlashingProposer() {
+    const slasherAddress = await this.rollup.read.getSlasher();
+    const slasher = getContract({ address: slasherAddress, abi: SlasherAbi, client: this.client });
+    const proposerAddress = await slasher.read.PROPOSER();
+    return new SlashingProposerContract(this.client, proposerAddress);
   }
 
   @memoize
@@ -35,7 +93,42 @@ export class RollupContract {
 
   @memoize
   getL1GenesisTime() {
-    return this.rollup.read.GENESIS_TIME();
+    return this.rollup.read.getGenesisTime();
+  }
+
+  @memoize
+  getClaimDurationInL2Slots() {
+    return this.rollup.read.CLAIM_DURATION_IN_L2_SLOTS();
+  }
+
+  @memoize
+  getEpochDuration() {
+    return this.rollup.read.getEpochDuration();
+  }
+
+  @memoize
+  getSlotDuration() {
+    return this.rollup.read.getSlotDuration();
+  }
+
+  @memoize
+  getTargetCommitteeSize() {
+    return this.rollup.read.TARGET_COMMITTEE_SIZE();
+  }
+
+  @memoize
+  getMinimumStake() {
+    return this.rollup.read.getMinimumStake();
+  }
+
+  public async getSlashingProposerAddress() {
+    const slasherAddress = await this.rollup.read.getSlasher();
+    const slasher = getContract({
+      address: getAddress(slasherAddress.toString()),
+      abi: SlasherAbi,
+      client: this.client,
+    });
+    return EthAddress.fromString(await slasher.read.PROPOSER());
   }
 
   getBlockNumber() {
@@ -70,25 +163,192 @@ export class RollupContract {
     return this.rollup.read.getCurrentProposer();
   }
 
+  getProposerAt(timestamp: bigint) {
+    return this.rollup.read.getProposerAt([timestamp]);
+  }
+
+  getBlock(blockNumber: bigint) {
+    return this.rollup.read.getBlock([blockNumber]);
+  }
+
+  getProofCommitmentEscrow() {
+    return this.rollup.read.PROOF_COMMITMENT_ESCROW();
+  }
+
+  getTips() {
+    return this.rollup.read.getTips();
+  }
+
+  getTimestampForSlot(slot: bigint) {
+    return this.rollup.read.getTimestampForSlot([slot]);
+  }
+
   async getEpochNumber(blockNumber?: bigint) {
     blockNumber ??= await this.getBlockNumber();
     return this.rollup.read.getEpochForBlock([BigInt(blockNumber)]);
   }
 
-  static getFromL1ContractsValues(deployL1ContractsValues: DeployL1Contracts) {
+  async getRollupAddresses(): Promise<L1RollupContractAddresses> {
+    const [
+      inboxAddress,
+      outboxAddress,
+      feeJuicePortalAddress,
+      rewardDistributorAddress,
+      feeJuiceAddress,
+      stakingAssetAddress,
+    ] = (
+      await Promise.all([
+        this.rollup.read.INBOX(),
+        this.rollup.read.OUTBOX(),
+        this.rollup.read.FEE_JUICE_PORTAL(),
+        this.rollup.read.REWARD_DISTRIBUTOR(),
+        this.rollup.read.ASSET(),
+        this.rollup.read.getStakingAsset(),
+      ] as const)
+    ).map(EthAddress.fromString);
+
+    return {
+      rollupAddress: EthAddress.fromString(this.address),
+      inboxAddress,
+      outboxAddress,
+      feeJuicePortalAddress,
+      feeJuiceAddress,
+      stakingAssetAddress,
+      rewardDistributorAddress,
+    };
+  }
+
+  public async getEpochNumberForSlotNumber(slotNumber: bigint): Promise<bigint> {
+    return await this.rollup.read.getEpochAtSlot([slotNumber]);
+  }
+
+  getEpochProofPublicInputs(
+    args: readonly [
+      bigint,
+      readonly [
+        `0x${string}`,
+        `0x${string}`,
+        `0x${string}`,
+        `0x${string}`,
+        `0x${string}`,
+        `0x${string}`,
+        `0x${string}`,
+      ],
+      readonly `0x${string}`[],
+      `0x${string}`,
+      `0x${string}`,
+    ],
+  ) {
+    return this.rollup.read.getEpochProofPublicInputs(args);
+  }
+  public async getProofClaim() {
     const {
-      publicClient,
-      l1ContractAddresses: { rollupAddress },
-    } = deployL1ContractsValues;
-    return new RollupContract(publicClient, rollupAddress.toString());
+      epochToProve,
+      basisPointFee,
+      bondAmount,
+      bondProvider: bondProviderHex,
+      proposerClaimant: proposerClaimantHex,
+    } = await this.rollup.read.getProofClaim();
+
+    const bondProvider = EthAddress.fromString(bondProviderHex);
+    const proposerClaimant = EthAddress.fromString(proposerClaimantHex);
+
+    if (bondProvider.isZero() && proposerClaimant.isZero() && epochToProve === 0n) {
+      return undefined;
+    }
+
+    return {
+      epochToProve,
+      basisPointFee,
+      bondAmount,
+      bondProvider,
+      proposerClaimant,
+    };
   }
 
-  static getFromConfig(config: L1ReaderConfig) {
-    const client = createPublicClient({
-      transport: http(config.l1RpcUrl),
-      chain: createEthereumChain(config.l1RpcUrl, config.l1ChainId).chainInfo,
-    });
-    const address = config.l1Contracts.rollupAddress.toString();
-    return new RollupContract(client, address);
+  async getClaimableEpoch(): Promise<bigint | undefined> {
+    try {
+      return await this.rollup.read.getClaimableEpoch();
+    } catch (err: unknown) {
+      throw formatViemError(err);
+    }
+  }
+
+  public async getEpochToProve(): Promise<bigint | undefined> {
+    try {
+      return await this.rollup.read.getEpochToProve();
+    } catch (err: unknown) {
+      throw formatViemError(err);
+    }
+  }
+
+  public async validateProofQuote(
+    quote: {
+      quote: EpochProofQuoteViemArgs;
+      signature: ViemSignature;
+    },
+    account: `0x${string}` | Account,
+    slotDuration: bigint | number,
+  ): Promise<void> {
+    if (typeof slotDuration === 'number') {
+      slotDuration = BigInt(slotDuration);
+    }
+    const timeOfNextL1Slot = BigInt((await this.client.getBlock()).timestamp + slotDuration);
+    const args = [timeOfNextL1Slot, quote] as const;
+    try {
+      await this.rollup.read.validateEpochProofRightClaimAtTime(args, { account });
+    } catch (err) {
+      throw formatViemError(err);
+    }
+  }
+
+  public async validateHeader(
+    args: readonly [
+      `0x${string}`,
+      ViemSignature[],
+      `0x${string}`,
+      bigint,
+      `0x${string}`,
+      {
+        ignoreDA: boolean;
+        ignoreSignatures: boolean;
+      },
+    ],
+    account: `0x${string}` | Account,
+  ): Promise<void> {
+    try {
+      await this.rollup.read.validateHeader(args, { account });
+    } catch (error: unknown) {
+      throw formatViemError(error);
+    }
+  }
+
+  /**
+   * @notice  Calls `canProposeAtTime` with the time of the next Ethereum block and the sender address
+   *
+   * @dev     Throws if unable to propose
+   *
+   * @param archive - The archive that we expect to be current state
+   * @return [slot, blockNumber] - If you can propose, the L2 slot number and L2 block number of the next Ethereum block,
+   * @throws otherwise
+   */
+  public async canProposeAtNextEthBlock(
+    archive: Buffer,
+    account: `0x${string}` | Account,
+    slotDuration: bigint | number,
+  ): Promise<[bigint, bigint]> {
+    if (typeof slotDuration === 'number') {
+      slotDuration = BigInt(slotDuration);
+    }
+    const timeOfNextL1Slot = (await this.client.getBlock()).timestamp + slotDuration;
+    try {
+      const [slot, blockNumber] = await this.rollup.read.canProposeAtTime(
+        [timeOfNextL1Slot, `0x${archive.toString('hex')}`],
+        { account },
+      );
+      return [slot, blockNumber];
+    } catch (err: unknown) {
+      throw formatViemError(err);
+    }
   }
 }

package/src/contracts/slashing_proposer.ts

@@ -0,0 +1,58 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { SlashingProposerAbi } from '@aztec/l1-artifacts';
+
+import {
+  type Chain,
+  type GetContractReturnType,
+  type Hex,
+  type HttpTransport,
+  type PublicClient,
+  getContract,
+} from 'viem';
+
+import type { L1Clients } from '../deploy_l1_contracts.js';
+import type { L1TxRequest } from '../l1_tx_utils.js';
+import { type IEmpireBase, encodeVote } from './empire_base.js';
+
+export class SlashingProposerContract implements IEmpireBase {
+  private readonly proposer: GetContractReturnType<typeof SlashingProposerAbi, PublicClient<HttpTransport, Chain>>;
+
+  constructor(public readonly client: L1Clients['publicClient'], address: Hex) {
+    this.proposer = getContract({ address, abi: SlashingProposerAbi, client });
+  }
+
+  public get address() {
+    return EthAddress.fromString(this.proposer.address);
+  }
+
+  public getQuorumSize() {
+    return this.proposer.read.N();
+  }
+
+  public getRoundSize() {
+    return this.proposer.read.M();
+  }
+
+  public computeRound(slot: bigint): Promise<bigint> {
+    return this.proposer.read.computeRound([slot]);
+  }
+
+  public async getRoundInfo(
+    rollupAddress: Hex,
+    round: bigint,
+  ): Promise<{ lastVote: bigint; leader: Hex; executed: boolean }> {
+    const roundInfo = await this.proposer.read.rounds([rollupAddress, round]);
+    return {
+      lastVote: roundInfo[0],
+      leader: roundInfo[1],
+      executed: roundInfo[2],
+    };
+  }
+
+  public createVoteRequest(payload: Hex): L1TxRequest {
+    return {
+      to: this.address.toString(),
+      data: encodeVote(payload),
+    };
+  }
+}

package/src/deploy_l1_contracts.ts

@@ -9,14 +9,14 @@ import {
   ExtRollupLibBytecode,
   FeeJuicePortalAbi,
   FeeJuicePortalBytecode,
+  ForwarderAbi,
+  ForwarderBytecode,
   GovernanceAbi,
   GovernanceBytecode,
   GovernanceProposerAbi,
   GovernanceProposerBytecode,
   InboxAbi,
   InboxBytecode,
-  LeonidasLibAbi,
-  LeonidasLibBytecode,
   OutboxAbi,
   OutboxBytecode,
   RegistryAbi,
@@ -28,18 +28,27 @@ import {
   RollupLinkReferences,
   SlashFactoryAbi,
   SlashFactoryBytecode,
+  StakingLibAbi,
+  StakingLibBytecode,
   TestERC20Abi,
   TestERC20Bytecode,
+  ValidatorSelectionLibAbi,
+  ValidatorSelectionLibBytecode,
 } from '@aztec/l1-artifacts';
 
 import type { Abi, Narrow } from 'abitype';
 import {
   type Account,
   type Chain,
+  type Client,
   type Hex,
   type HttpTransport,
+  type PublicActions,
   type PublicClient,
+  type PublicRpcSchema,
+  type WalletActions,
   type WalletClient,
+  type WalletRpcSchema,
   concatHex,
   createPublicClient,
   createWalletClient,
@@ -50,15 +59,18 @@ import {
   http,
   numberToHex,
   padHex,
+  publicActions,
 } from 'viem';
 import { type HDAccount, type PrivateKeyAccount, mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
 import { foundry } from 'viem/chains';
 
+import { isAnvilTestChain } from './chain.js';
 import { type L1ContractsConfig } from './config.js';
-import { isAnvilTestChain } from './ethereum_chain.js';
 import { type L1ContractAddresses } from './l1_contract_addresses.js';
 import { L1TxUtils } from './l1_tx_utils.js';
 
+export const DEPLOYER_ADDRESS: Hex = '0x4e59b44847b379578588920cA78FbF26c0B4956C';
+
 /**
  * Return type of the deployL1Contract function.
  */
@@ -128,14 +140,18 @@ export const l1Artifacts = {
     libraries: {
       linkReferences: RollupLinkReferences,
       libraryCode: {
-        LeonidasLib: {
-          contractAbi: LeonidasLibAbi,
-          contractBytecode: LeonidasLibBytecode as Hex,
+        ValidatorSelectionLib: {
+          contractAbi: ValidatorSelectionLibAbi,
+          contractBytecode: ValidatorSelectionLibBytecode as Hex,
         },
         ExtRollupLib: {
           contractAbi: ExtRollupLibAbi,
           contractBytecode: ExtRollupLibBytecode as Hex,
         },
+        StakingLib: {
+          contractAbi: StakingLibAbi,
+          contractBytecode: StakingLibBytecode as Hex,
+        },
       },
     },
   },
@@ -190,7 +206,13 @@ export interface DeployL1ContractsArgs extends L1ContractsConfig {
 
 export type L1Clients = {
   publicClient: PublicClient<HttpTransport, Chain>;
-  walletClient: WalletClient<HttpTransport, Chain, Account>;
+  walletClient: Client<
+    HttpTransport,
+    Chain,
+    PrivateKeyAccount,
+    [...WalletRpcSchema, ...PublicRpcSchema],
+    PublicActions<HttpTransport, Chain> & WalletActions<Chain, PrivateKeyAccount>
+  >;
 };
 
 /**
@@ -212,18 +234,25 @@ export function createL1Clients(
         : mnemonicToAccount(mnemonicOrPrivateKeyOrHdAccount)
       : mnemonicOrPrivateKeyOrHdAccount;
 
+  // From what I can see, this is the difference between the HDAccount and the PrivateKeyAccount
+  // and we don't need it for anything. This lets us use the same type for both.
+  // eslint-disable-next-line camelcase
+  hdAccount.experimental_signAuthorization ??= () => {
+    throw new Error('experimental_signAuthorization not implemented for HDAccount');
+  };
+
   const walletClient = createWalletClient({
     account: hdAccount,
     chain,
     transport: http(rpcUrl),
-  });
+  }).extend(publicActions);
   const publicClient = createPublicClient({
     chain,
     transport: http(rpcUrl),
     pollingInterval: 100,
   });
 
-  return { walletClient, publicClient };
+  return { walletClient, publicClient } as L1Clients;
 }
 
 /**
@@ -414,18 +443,18 @@ export const deployL1Contracts = async (
         ].map(txHash => publicClient.waitForTransactionReceipt({ hash: txHash })),
       );
 
-      const initiateValidatorSetTxHash = await rollup.write.cheat__InitialiseValidatorSet([
-        newValidatorsAddresses.map(v => ({
-          attester: v,
-          proposer: v,
-          withdrawer: v,
-          amount: args.minimumStake,
-        })),
-      ]);
+      const validators = newValidatorsAddresses.map(v => ({
+        attester: v,
+        proposer: getExpectedAddress(ForwarderAbi, ForwarderBytecode, [v], v).address,
+        withdrawer: v,
+        amount: args.minimumStake,
+      }));
+      const initiateValidatorSetTxHash = await rollup.write.cheat__InitialiseValidatorSet([validators]);
       txHashes.push(initiateValidatorSetTxHash);
-      logger.info(
-        `Initialized validator set (${newValidatorsAddresses.join(', ')}) in tx ${initiateValidatorSetTxHash}`,
-      );
+      logger.info(`Initialized validator set`, {
+        validators,
+        txHash: initiateValidatorSetTxHash,
+      });
     }
   }
 
@@ -663,15 +692,12 @@ export async function deployL1Contract(
   }
 
   if (maybeSalt) {
-    const salt = padHex(maybeSalt, { size: 32 });
-    const deployer: Hex = '0x4e59b44847b379578588920cA78FbF26c0B4956C';
-    const calldata = encodeDeployData({ abi, bytecode, args });
-    resultingAddress = getContractAddress({ from: deployer, salt, bytecode: calldata, opcode: 'CREATE2' });
+    const { address, paddedSalt: salt, calldata } = getExpectedAddress(abi, bytecode, args, maybeSalt);
+    resultingAddress = address;
     const existing = await publicClient.getBytecode({ address: resultingAddress });
-
     if (existing === undefined || existing === '0x') {
       const res = await l1TxUtils.sendTransaction({
-        to: deployer,
+        to: DEPLOYER_ADDRESS,
         data: concatHex([salt, calldata]),
       });
       txHash = res.txHash;
@@ -701,4 +727,26 @@ export async function deployL1Contract(
 
   return { address: EthAddress.fromString(resultingAddress!), txHash };
 }
+
+export function getExpectedAddress(
+  abi: Narrow<Abi | readonly unknown[]>,
+  bytecode: Hex,
+  args: readonly unknown[],
+  salt: Hex,
+) {
+  const paddedSalt = padHex(salt, { size: 32 });
+  const calldata = encodeDeployData({ abi, bytecode, args });
+  const address = getContractAddress({
+    from: DEPLOYER_ADDRESS,
+    salt: paddedSalt,
+    bytecode: calldata,
+    opcode: 'CREATE2',
+  });
+  return {
+    address,
+    paddedSalt,
+    calldata,
+  };
+}
+
 // docs:end:deployL1Contract

package/src/index.ts

@@ -1,11 +1,14 @@
 export * from './constants.js';
 export * from './deploy_l1_contracts.js';
-export * from './ethereum_chain.js';
+export * from './chain.js';
 export * from './eth_cheat_codes.js';
 export * from './l1_tx_utils.js';
+export * from './l1_tx_utils_with_blobs.js';
 export * from './l1_contract_addresses.js';
 export * from './l1_reader.js';
 export * from './utils.js';
 export * from './config.js';
 export * from './types.js';
 export * from './contracts/index.js';
+export * from './queries.js';
+export * from './client.js';

package/src/l1_reader.ts

@@ -25,10 +25,9 @@ export const l1ReaderConfigMappings: ConfigMappingsType<L1ReaderConfig> = {
     defaultValue: 31337,
     description: 'The chain ID of the ethereum host.',
   },
-  // NOTE: Special case for l1Contracts
   l1Contracts: {
     description: 'The deployed L1 contract addresses',
-    defaultValue: l1ContractAddressesMapping,
+    nested: l1ContractAddressesMapping,
   },
   viemPollingIntervalMS: {
     env: 'L1_READER_VIEM_POLLING_INTERVAL_MS',