@aztec/ethereum 4.0.0-nightly.20260113 → 4.0.0-nightly.20260115

package/src/contracts/README.md

@@ -0,0 +1,157 @@
+# L1 Contract Wrappers
+
+This folder contains TypeScript wrappers for L1 contracts defined in `l1-contracts/`. These wrappers are used by the node client to interact with the rollup and related contracts on Ethereum.
+
+## Purpose
+
+The goal of wrapping is to shield consumers from L1-specific and viem-specific details. Clients using these wrappers interact with domain types and branded types native to the Aztec codebase, without needing to understand viem's ABI type system or deal with raw types like `Hex` and `bigint`.
+
+## Type Safety
+
+### Explicit Return Types
+
+Every function in the contract wrappers must declare its return type explicitly. This is critical because viem's type inference over ABI types is slow and significantly impacts IDE performance.
+
+```typescript
+// Good: Explicit return type
+async getSlotNumber(): Promise<SlotNumber> {
+  return SlotNumber.fromBigInt(await this.rollup.read.getCurrentSlot());
+}
+
+// Bad: Inferred return type (slow)
+async getSlotNumber() {
+  return SlotNumber.fromBigInt(await this.rollup.read.getCurrentSlot());
+}
+```
+
+### Branded and Domain Types
+
+Use branded types and domain-specific types instead of viem's autogenerated types for both arguments and return values:
+
+- `CheckpointNumber`, `EpochNumber`, `SlotNumber` instead of `bigint`
+- `EthAddress` instead of `` `0x${string}` `` or `Hex`
+- `Fr`, `Buffer32` instead of `Hex` for hashes and field elements
+- Custom domain types (e.g., `CheckpointLog`, `AttesterView`) instead of raw tuples
+
+Type conversions happen inside wrapper methods, not at the call site:
+
+```typescript
+async getCheckpoint(checkpointNumber: CheckpointNumber): Promise<CheckpointLog> {
+  const result = await this.rollup.read.getCheckpoint([BigInt(checkpointNumber)]);
+  return {
+    archive: Fr.fromString(result.archive),
+    headerHash: Buffer32.fromString(result.headerHash),
+    blockCount: result.blockCount,
+  };
+}
+```
+
+## Wrapper Pattern
+
+### Basic Structure
+
+Each wrapper follows a consistent structure:
+
+```typescript
+export class FooContract {
+  private readonly foo: GetContractReturnType<typeof FooAbi, ViemClient>;
+
+  constructor(
+    public readonly client: ViemClient,
+    address: Hex | EthAddress,
+  ) {
+    if (address instanceof EthAddress) {
+      address = address.toString();
+    }
+    this.foo = getContract({ address, abi: FooAbi, client });
+  }
+
+  public get address(): Hex {
+    return this.foo.address;
+  }
+
+  public getContract(): GetContractReturnType<typeof FooAbi, ViemClient> {
+    return this.foo;
+  }
+}
+```
+
+The raw contract is exposed via `getContract()` for cases where direct access is needed, but most consumers should use the typed wrapper methods. Relying on `getContract()` is a code smell and should be avoided.
+
+### Static Factory Methods
+
+Wrappers may provide static factory methods for common initialization patterns:
+
+- `getFromConfig(config)` - construct from configuration object
+- `getFromL1ContractsValues(deployResult)` - construct from deployment result
+
+### Wallet Assertions
+
+For write operations that require a wallet, use an assertion helper:
+
+```typescript
+private assertWallet(): GetContractReturnType<typeof FooAbi, ExtendedViemWalletClient> {
+  if (!isExtendedClient(this.client)) {
+    throw new Error('Wallet client is required for this operation');
+  }
+  return this.foo as GetContractReturnType<typeof FooAbi, ExtendedViemWalletClient>;
+}
+```
+
+## Event Handling
+
+### Event Log Types
+
+Event logs are wrapped in `L1EventLog<T>` to include L1 block context:
+
+```typescript
+type L1EventLog<T> = {
+  l1BlockNumber: bigint;
+  l1BlockHash: Buffer32;
+  l1TransactionHash: Hex;
+  args: T;
+};
+```
+
+### Event Fetching
+
+Methods that fetch events convert viem's raw logs to domain types:
+
+```typescript
+async getCheckpointProposedEvents(fromBlock: bigint, toBlock: bigint): Promise<CheckpointProposedLog[]> {
+  const logs = await this.rollup.getEvents.CheckpointProposed({}, { fromBlock, toBlock });
+  return logs.map(log => ({
+    l1BlockNumber: log.blockNumber!,
+    l1BlockHash: Buffer32.fromString(log.blockHash!),
+    l1TransactionHash: log.transactionHash!,
+    args: {
+      checkpointNumber: CheckpointNumber.fromBigInt(log.args.checkpointNumber!),
+      // ... convert other fields
+    },
+  }));
+}
+```
+
+### Event Listeners
+
+For reactive event handling, wrapper methods convert arguments before invoking callbacks:
+
+```typescript
+public listenToCheckpointInvalidated(
+  callback: (args: { checkpointNumber: CheckpointNumber }) => unknown,
+): WatchContractEventReturnType {
+  return this.rollup.watchEvent.CheckpointInvalidated({}, {
+    onLogs: logs => {
+      for (const log of logs) {
+        if (log.args.checkpointNumber !== undefined) {
+          callback({ checkpointNumber: CheckpointNumber.fromBigInt(log.args.checkpointNumber) });
+        }
+      }
+    },
+  });
+}
+```
+
+## Error Handling
+
+Custom error classes in `errors.ts` extend `Error` and set `this.name` for proper error identification. Include relevant context as public readonly properties.

package/src/contracts/inbox.ts

@@ -1,4 +1,6 @@
-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';
 
@@ -8,8 +10,20 @@ 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 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>;
 
@@ -59,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

@@ -6,6 +6,7 @@ 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';

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/rollup.ts

@@ -30,6 +30,7 @@ import type { ViemClient } from '../types.js';
 import { formatViemError } from '../utils.js';
 import { EmpireSlashingProposerContract } from './empire_slashing_proposer.js';
 import { GSEContract } from './gse.js';
+import type { L1EventLog } from './log.js';
 import { SlasherContract } from './slasher_contract.js';
 import { TallySlashingProposerContract } from './tally_slashing_proposer.js';
 import { checkBlockTag } from './utils.js';
@@ -69,6 +70,7 @@ export type ViemHeader = {
   blockHeadersHash: `0x${string}`;
   blobsHash: `0x${string}`;
   inHash: `0x${string}`;
+  outHash: `0x${string}`;
   slotNumber: bigint;
   timestamp: bigint;
   coinbase: `0x${string}`;
@@ -185,6 +187,20 @@ export type RollupStatusResponse = {
   archiveOfMyCheckpoint: Fr;
 };
 
+/** Arguments for the CheckpointProposed event. */
+export type CheckpointProposedArgs = {
+  checkpointNumber: CheckpointNumber;
+  archive: Fr;
+  versionedBlobHashes: Buffer[];
+  /** Hash of attestations. Undefined for older events (backwards compatibility). */
+  attestationsHash?: Buffer32;
+  /** Digest of the payload. Undefined for older events (backwards compatibility). */
+  payloadDigest?: Buffer32;
+};
+
+/** Log type for CheckpointProposed events. */
+export type CheckpointProposedLog = L1EventLog<CheckpointProposedArgs>;
+
 export class RollupContract {
   private readonly rollup: GetContractReturnType<typeof RollupAbi, ViemClient>;
 
@@ -965,4 +981,23 @@ export class RollupContract {
       },
     );
   }
+
+  /** Fetches CheckpointProposed events within the given block range. */
+  async getCheckpointProposedEvents(fromBlock: bigint, toBlock: bigint): Promise<CheckpointProposedLog[]> {
+    const logs = await this.rollup.getEvents.CheckpointProposed({}, { fromBlock, toBlock });
+    return logs
+      .filter(log => log.blockNumber! >= fromBlock && log.blockNumber! <= toBlock)
+      .map(log => ({
+        l1BlockNumber: log.blockNumber!,
+        l1BlockHash: Buffer32.fromString(log.blockHash!),
+        l1TransactionHash: log.transactionHash!,
+        args: {
+          checkpointNumber: CheckpointNumber.fromBigInt(log.args.checkpointNumber!),
+          archive: Fr.fromString(log.args.archive!),
+          versionedBlobHashes: log.args.versionedBlobHashes!.map(h => Buffer.from(h.slice(2), 'hex')),
+          attestationsHash: log.args.attestationsHash ? Buffer32.fromString(log.args.attestationsHash) : undefined,
+          payloadDigest: log.args.payloadDigest ? Buffer32.fromString(log.args.payloadDigest) : undefined,
+        },
+      }));
+  }
 }

package/src/deploy_aztec_l1_contracts.ts

@@ -10,7 +10,7 @@ import { fileURLToPath } from '@aztec/foundation/url';
 import { bn254 } from '@noble/curves/bn254';
 import type { Abi, Narrow } from 'abitype';
 import { spawn } from 'child_process';
-import { cpSync, existsSync, mkdirSync, mkdtempSync, readdirSync, rmSync } from 'fs';
+import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'fs';
 import { tmpdir } from 'os';
 import { dirname, join, resolve } from 'path';
 import readline from 'readline';
@@ -141,11 +141,14 @@ function cleanupDeployDir() {
  */
 export function prepareL1ContractsForDeployment(): string {
   if (preparedDeployDir && existsSync(preparedDeployDir)) {
+    logger.verbose(`Using cached deployment directory: ${preparedDeployDir}`);
     return preparedDeployDir;
   }
 
   const basePath = getL1ContractsPath();
+  logger.verbose(`Preparing L1 contracts from: ${basePath}`);
   const tempDir = mkdtempSync(join(tmpdir(), '.foundry-deploy-'));
+  logger.verbose(`Created temp directory for deployment: ${tempDir}`);
   preparedDeployDir = tempDir;
   process.on('exit', cleanupDeployDir);
 
@@ -157,13 +160,21 @@ export function prepareL1ContractsForDeployment(): string {
   cpSync(join(basePath, 'src'), join(tempDir, 'src'), copyOpts);
   cpSync(join(basePath, 'script'), join(tempDir, 'script'), copyOpts);
   cpSync(join(basePath, 'generated'), join(tempDir, 'generated'), copyOpts);
-  cpSync(join(basePath, 'foundry.toml'), join(tempDir, 'foundry.toml'));
+  // Kludge: copy test/ to appease forge cache which references test/shouting.t.sol
+  cpSync(join(basePath, 'test'), join(tempDir, 'test'), copyOpts);
   cpSync(join(basePath, 'foundry.lock'), join(tempDir, 'foundry.lock'));
-  for (const file of readdirSync(basePath)) {
-    if (file.startsWith('solc-')) {
-      cpSync(join(basePath, file), join(tempDir, file));
-    }
+
+  // Update foundry.toml to use absolute path to solc binary (avoids copying to noexec tmpfs)
+  const foundryTomlPath = join(basePath, 'foundry.toml');
+  let foundryToml = readFileSync(foundryTomlPath, 'utf-8');
+  const solcPathMatch = foundryToml.match(/solc\s*=\s*"\.\/solc-([^"]+)"/);
+  if (solcPathMatch) {
+    const solcVersion = solcPathMatch[1];
+    const absoluteSolcPath = join(basePath, `solc-${solcVersion}`);
+    foundryToml = foundryToml.replace(/solc\s*=\s*"\.\/solc-[^"]+"/, `solc = "${absoluteSolcPath}"`);
+    logger.verbose(`Updated solc path in foundry.toml to: ${absoluteSolcPath}`);
   }
+  writeFileSync(join(tempDir, 'foundry.toml'), foundryToml);
 
   mkdirSync(join(tempDir, 'broadcast'));
   return tempDir;