@aztec/ethereum 0.0.0-test.1 → 0.0.1-commit.1142ef1

package/src/contracts/governance_proposer.ts

@@ -1,17 +1,32 @@
+import { SlotNumber } from '@aztec/foundation/branded-types';
 import { memoize } from '@aztec/foundation/decorators';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { GovernanceProposerAbi } from '@aztec/l1-artifacts';
+import { GovernanceProposerAbi } from '@aztec/l1-artifacts/GovernanceProposerAbi';
 
-import { type GetContractReturnType, type Hex, type TransactionReceipt, encodeFunctionData, getContract } from 'viem';
+import {
+  type GetContractReturnType,
+  type Hex,
+  type TransactionReceipt,
+  type TypedDataDefinition,
+  encodeFunctionData,
+  getContract,
+} from 'viem';
 
-import type { GasPrice, L1TxRequest, L1TxUtils } from '../l1_tx_utils.js';
-import type { ViemPublicClient } from '../types.js';
-import { type IEmpireBase, encodeVote } from './empire_base.js';
+import type { L1TxRequest, L1TxUtils } from '../l1_tx_utils/index.js';
+import type { ViemClient } from '../types.js';
+import { type IEmpireBase, encodeSignal, encodeSignalWithSignature, signSignalWithSig } from './empire_base.js';
+import { extractProposalIdFromLogs } from './governance.js';
 
 export class GovernanceProposerContract implements IEmpireBase {
-  private readonly proposer: GetContractReturnType<typeof GovernanceProposerAbi, ViemPublicClient>;
+  private readonly proposer: GetContractReturnType<typeof GovernanceProposerAbi, ViemClient>;
 
-  constructor(public readonly client: ViemPublicClient, address: Hex) {
+  constructor(
+    public readonly client: ViemClient,
+    address: Hex | EthAddress,
+  ) {
+    if (address instanceof EthAddress) {
+      address = address.toString();
+    }
     this.proposer = getContract({ address, abi: GovernanceProposerAbi, client });
   }
 
@@ -29,54 +44,86 @@ export class GovernanceProposerContract implements IEmpireBase {
   }
 
   public getQuorumSize(): Promise<bigint> {
-    return this.proposer.read.N();
+    return this.proposer.read.QUORUM_SIZE();
   }
 
   public getRoundSize(): Promise<bigint> {
-    return this.proposer.read.M();
+    return this.proposer.read.ROUND_SIZE();
   }
 
-  public computeRound(slot: bigint): Promise<bigint> {
-    return this.proposer.read.computeRound([slot]);
+  public getInstance() {
+    return this.proposer.read.getInstance();
+  }
+
+  public computeRound(slot: SlotNumber): Promise<bigint> {
+    return this.proposer.read.computeRound([BigInt(slot)]);
   }
 
   public async getRoundInfo(
     rollupAddress: Hex,
     round: bigint,
-  ): Promise<{ lastVote: bigint; leader: Hex; executed: boolean }> {
-    const roundInfo = await this.proposer.read.rounds([rollupAddress, round]);
+  ): 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 {
-      lastVote: roundInfo[0],
-      leader: roundInfo[1],
-      executed: roundInfo[2],
+      lastSignalSlot: SlotNumber.fromBigInt(result.lastSignalSlot),
+      payloadWithMostSignals: result.payloadWithMostSignals,
+      quorumReached: signalCount >= quorum,
+      executed: result.executed,
     };
   }
 
-  public getProposalVotes(rollupAddress: Hex, round: bigint, proposal: Hex): Promise<bigint> {
-    return this.proposer.read.yeaCount([rollupAddress, round, proposal]);
+  public getPayloadSignals(rollupAddress: Hex, round: bigint, payload: Hex): Promise<bigint> {
+    return this.proposer.read.signalCount([rollupAddress, round, payload]);
+  }
+
+  public createSignalRequest(payload: Hex): L1TxRequest {
+    return {
+      to: this.address.toString(),
+      data: encodeSignal(payload),
+    };
   }
 
-  public createVoteRequest(payload: Hex): L1TxRequest {
+  public async createSignalRequestWithSignature(
+    payload: Hex,
+    slot: SlotNumber,
+    chainId: number,
+    signerAddress: Hex,
+    signer: (msg: TypedDataDefinition) => Promise<Hex>,
+  ): Promise<L1TxRequest> {
+    const signature = await signSignalWithSig(
+      signer,
+      payload,
+      slot,
+      await this.getInstance(),
+      this.address.toString(),
+      chainId,
+    );
     return {
       to: this.address.toString(),
-      data: encodeVote(payload),
+      data: encodeSignalWithSignature(payload, signature),
     };
   }
 
-  public executeProposal(
+  public async submitRoundWinner(
     round: bigint,
     l1TxUtils: L1TxUtils,
   ): Promise<{
     receipt: TransactionReceipt;
-    gasPrice: GasPrice;
+    proposalId: bigint;
   }> {
-    return l1TxUtils.sendAndMonitorTransaction({
+    const { receipt } = await l1TxUtils.sendAndMonitorTransaction({
       to: this.address.toString(),
       data: encodeFunctionData({
         abi: this.proposer.abi,
-        functionName: 'executeProposal',
+        functionName: 'submitRoundWinner',
         args: [round],
       }),
     });
+    const proposalId = extractProposalIdFromLogs(receipt.logs);
+    return { receipt, proposalId };
   }
 }

package/src/contracts/gse.ts

@@ -0,0 +1,88 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { GSEAbi } from '@aztec/l1-artifacts/GSEAbi';
+
+import type { ProjPointType } from '@noble/curves/abstract/weierstrass';
+import { bn254 } from '@noble/curves/bn254';
+import { type GetContractReturnType, type Hex, getContract } from 'viem';
+
+import type { ViemClient } from '../types.js';
+
+export type RegistrationTuple = {
+  publicKeyInG1: {
+    x: bigint;
+    y: bigint;
+  };
+  publicKeyInG2: {
+    x0: bigint;
+    x1: bigint;
+    y0: bigint;
+    y1: bigint;
+  };
+  proofOfPossession: {
+    x: bigint;
+    y: bigint;
+  };
+};
+
+export class GSEContract {
+  public address: EthAddress;
+  private readonly gse: GetContractReturnType<typeof GSEAbi, ViemClient>;
+
+  constructor(
+    public readonly client: ViemClient,
+    address: Hex | EthAddress,
+  ) {
+    if (address instanceof EthAddress) {
+      address = address.toString();
+    }
+    this.address = EthAddress.fromString(address);
+    this.gse = getContract({ address, abi: GSEAbi, client });
+  }
+
+  public async getOwner(): Promise<EthAddress> {
+    return EthAddress.fromString(await this.gse.read.owner());
+  }
+
+  public async getGovernance(): Promise<EthAddress> {
+    return EthAddress.fromString(await this.gse.read.getGovernance());
+  }
+
+  getAttestersFromIndicesAtTime(instance: Hex | EthAddress, ts: bigint, indices: bigint[]) {
+    if (instance instanceof EthAddress) {
+      instance = instance.toString();
+    }
+    return this.gse.read.getAttestersFromIndicesAtTime([instance, ts, indices]);
+  }
+
+  public async getRegistrationDigest(publicKey: ProjPointType<bigint>): Promise<ProjPointType<bigint>> {
+    const affinePublicKey = publicKey.toAffine();
+    const g1PointDigest = await this.gse.read.getRegistrationDigest([{ x: affinePublicKey.x, y: affinePublicKey.y }]);
+    return bn254.G1.ProjectivePoint.fromAffine(g1PointDigest);
+  }
+
+  public async makeRegistrationTuple(privateKey: bigint): Promise<RegistrationTuple> {
+    const publicKeyG1 = bn254.G1.ProjectivePoint.BASE.multiply(privateKey);
+    const digest = await this.getRegistrationDigest(publicKeyG1);
+    const signature = digest.multiply(privateKey);
+    const publicKeyG2 = bn254.G2.ProjectivePoint.BASE.multiply(privateKey);
+    const publicKeyG1Affine = publicKeyG1.toAffine();
+    const signatureAffine = signature.toAffine();
+    const publicKeyG2Affine = publicKeyG2.toAffine();
+    return {
+      publicKeyInG1: {
+        x: publicKeyG1Affine.x,
+        y: publicKeyG1Affine.y,
+      },
+      publicKeyInG2: {
+        x0: publicKeyG2Affine.x.c0,
+        x1: publicKeyG2Affine.x.c1,
+        y0: publicKeyG2Affine.y.c0,
+        y1: publicKeyG2Affine.y.c1,
+      },
+      proofOfPossession: {
+        x: signatureAffine.x,
+        y: signatureAffine.y,
+      },
+    };
+  }
+}

package/src/contracts/inbox.ts

@@ -0,0 +1,68 @@
+import { Buffer16 } from '@aztec/foundation/buffer';
+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 { DeployAztecL1ContractsReturnType } from '../deploy_aztec_l1_contracts.js';
+import type { L1ReaderConfig } from '../l1_reader.js';
+import type { ViemClient } from '../types.js';
+import { checkBlockTag } from './utils.js';
+
+export class InboxContract {
+  private readonly inbox: GetContractReturnType<typeof InboxAbi, ViemClient>;
+
+  static getFromL1ContractsValues(deployL1ContractsValues: DeployAztecL1ContractsReturnType) {
+    const {
+      l1Client,
+      l1ContractAddresses: { inboxAddress },
+    } = deployL1ContractsValues;
+    return new InboxContract(l1Client, inboxAddress.toString());
+  }
+
+  static getFromConfig(config: L1ReaderConfig) {
+    const client = getPublicClient(config);
+    const address = config.l1Contracts.inboxAddress.toString();
+    return new InboxContract(client, address);
+  }
+
+  constructor(
+    public readonly client: ViemClient,
+    address: Hex | EthAddress,
+  ) {
+    if (address instanceof EthAddress) {
+      address = address.toString();
+    }
+    this.inbox = getContract({ address, abi: InboxAbi, client });
+  }
+
+  public get address() {
+    return this.inbox.address;
+  }
+
+  public getContract(): GetContractReturnType<typeof InboxAbi, ViemClient> {
+    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);
+    return {
+      totalMessagesInserted: state.totalMessagesInserted,
+      messagesRollingHash: Buffer16.fromString(state.rollingHash),
+      treeInProgress: state.inProgress,
+    };
+  }
+}
+
+export type InboxContractState = {
+  totalMessagesInserted: bigint;
+  messagesRollingHash: Buffer16;
+  treeInProgress: bigint;
+};

package/src/contracts/index.ts

@@ -1,8 +1,15 @@
 export * from './empire_base.js';
+export * from './errors.js';
+export * from './fee_asset_handler.js';
 export * from './fee_juice.js';
-export * from './forwarder.js';
 export * from './governance.js';
 export * from './governance_proposer.js';
+export * from './gse.js';
+export * from './inbox.js';
+export * from './multicall.js';
+export * from './outbox.js';
 export * from './registry.js';
 export * from './rollup.js';
-export * from './slashing_proposer.js';
+export * from './empire_slashing_proposer.js';
+export * from './tally_slashing_proposer.js';
+export * from './slasher_contract.js';

package/src/contracts/multicall.ts

@@ -0,0 +1,155 @@
+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 { L1BlobInputs, L1TxConfig, L1TxRequest, L1TxUtils } from '../l1_tx_utils/index.js';
+import type { ExtendedViemWalletClient } from '../types.js';
+import { FormattedViemError, formatViemError } from '../utils.js';
+import { RollupContract } from './rollup.js';
+
+export const MULTI_CALL_3_ADDRESS = '0xcA11bde05977b3631167028862bE2a173976CA11' as const;
+
+export class Multicall3 {
+  static async forward(
+    requests: L1TxRequest[],
+    l1TxUtils: L1TxUtils,
+    gasConfig: L1TxConfig | undefined,
+    blobConfig: L1BlobInputs | undefined,
+    rollupAddress: Hex,
+    logger: Logger,
+    opts: { revertOnFailure?: boolean } = {},
+  ) {
+    requests = requests.filter(request => request.to !== null);
+    const args = requests.map(r => ({
+      target: r.to!,
+      callData: r.data!,
+      allowFailure: !opts.revertOnFailure,
+    }));
+    const forwarderFunctionData: Required<EncodeFunctionDataParameters<typeof multicall3Abi, 'aggregate3'>> = {
+      abi: multicall3Abi,
+      functionName: 'aggregate3',
+      args: [args],
+    };
+
+    const encodedForwarderData = encodeFunctionData(forwarderFunctionData);
+
+    try {
+      const { receipt, state } = await l1TxUtils.sendAndMonitorTransaction(
+        { to: MULTI_CALL_3_ADDRESS, data: encodedForwarderData },
+        gasConfig,
+        blobConfig,
+      );
+
+      if (receipt.status === 'success') {
+        const stats = await l1TxUtils.getTransactionStats(receipt.transactionHash);
+        return { receipt, stats };
+      } else {
+        logger.error('Forwarder transaction failed', undefined, { receipt });
+
+        const args = {
+          ...forwarderFunctionData,
+          address: MULTI_CALL_3_ADDRESS,
+        };
+
+        let errorMsg: string | undefined;
+
+        if (blobConfig) {
+          const maxFeePerBlobGas = blobConfig.maxFeePerBlobGas ?? state.gasPrice.maxFeePerBlobGas;
+          if (maxFeePerBlobGas === undefined) {
+            errorMsg = 'maxFeePerBlobGas is required to get the error message';
+          } else {
+            logger.debug('Trying to get error from reverted tx with blob config');
+            errorMsg = await l1TxUtils.tryGetErrorFromRevertedTx(
+              encodedForwarderData,
+              args,
+              {
+                blobs: blobConfig.blobs,
+                kzg: blobConfig.kzg,
+                maxFeePerBlobGas,
+              },
+              [
+                {
+                  address: rollupAddress,
+                  stateDiff: [
+                    {
+                      slot: toPaddedHex(RollupContract.checkBlobStorageSlot, true),
+                      value: toPaddedHex(0n, true),
+                    },
+                  ],
+                },
+              ],
+            );
+          }
+        } else {
+          logger.debug('Trying to get error from reverted tx without blob config');
+          errorMsg = await l1TxUtils.tryGetErrorFromRevertedTx(encodedForwarderData, args, undefined, []);
+        }
+
+        return { receipt, errorMsg };
+      }
+    } catch (err) {
+      if (err instanceof TimeoutError) {
+        throw err;
+      }
+
+      for (const request of requests) {
+        logger.debug('Simulating request', { request });
+        const result = await l1TxUtils
+          .simulate(request, undefined, [
+            {
+              address: rollupAddress,
+              stateDiff: [
+                { slot: toPaddedHex(RollupContract.checkBlobStorageSlot, true), value: toPaddedHex(0n, true) },
+              ],
+            },
+          ])
+          .catch(err => formatViemError(err, request.abi));
+        if (result instanceof FormattedViemError) {
+          logger.error('Found error in simulation', result, {
+            to: request.to ?? 'null',
+            data: request.data,
+          });
+
+          return result;
+        }
+      }
+      logger.warn('Failed to get error from reverted tx', { err });
+      throw err;
+    }
+  }
+}
+
+export async function deployMulticall3(l1Client: ExtendedViemWalletClient, logger: Logger) {
+  const existing = await l1Client.getCode({ address: MULTI_CALL_3_ADDRESS });
+  if (existing && existing !== '0x') {
+    logger.verbose('Multicall3 already deployed', { address: MULTI_CALL_3_ADDRESS });
+    return;
+  }
+
+  const deployer = '0x05f32b3cc3888453ff71b01135b34ff8e41263f2';
+  const sendEth = await l1Client.sendTransaction({ to: deployer, value: 10n ** 17n });
+  logger.info('Sent 0.1 ETH to deployer', { deployer, value: 10n ** 17n });
+  const sendEthReceipt = await l1Client.waitForTransactionReceipt({ hash: sendEth });
+  if (sendEthReceipt.status !== 'success') {
+    logger.error('Failed to send ETH to deployer', undefined, { sendEthReceipt });
+    throw new Error('Failed to send ETH to deployer');
+  } else {
+    logger.info('Sent 0.1 ETH to deployer', { deployer, value: 10n ** 17n });
+  }
+
+  const tx =
+    '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';
+
+  const deployTx = await l1Client.sendRawTransaction({
+    serializedTransaction: tx,
+  });
+  const deployTxReceipt = await l1Client.waitForTransactionReceipt({ hash: deployTx });
+  if (deployTxReceipt.status !== 'success') {
+    logger.error('Failed to deploy Multicall3', undefined, { deployTxReceipt });
+    throw new Error('Failed to deploy Multicall3');
+  } else {
+    logger.info('Deployed Multicall3');
+  }
+}

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>;
+  }
+}