@aztec/ethereum 0.0.0-test.1 → 0.0.1-commit.001888fc

package/src/client.ts

@@ -1,20 +1,41 @@
 import type { Logger } from '@aztec/foundation/log';
 import { retryUntil } from '@aztec/foundation/retry';
 
-import { createPublicClient, fallback, http } from 'viem';
+import {
+  type Chain,
+  type HDAccount,
+  type LocalAccount,
+  type PrivateKeyAccount,
+  createPublicClient,
+  createWalletClient,
+  fallback,
+  http,
+  publicActions,
+} from 'viem';
+import { mnemonicToAccount, privateKeyToAccount } from 'viem/accounts';
+import { foundry } from 'viem/chains';
 
 import { createEthereumChain } from './chain.js';
-import type { ViemPublicClient } from './types.js';
+import type { ExtendedViemWalletClient, ViemPublicClient } from './types.js';
 
 type Config = {
-  /** The RPC Url of the ethereum host. */
+  /** List of URLs of Ethereum RPC nodes that services will connect to (comma separated). */
   l1RpcUrls: string[];
   /** The chain ID of the ethereum host. */
   l1ChainId: number;
   /** The polling interval viem uses in ms */
   viemPollingIntervalMS?: number;
+  /** Timeout for HTTP requests to the L1 RPC node in ms. */
+  l1HttpTimeoutMS?: number;
 };
 
+export type { Config as EthereumClientConfig };
+
+/** Creates a viem fallback HTTP transport for the given L1 RPC URLs. */
+export function makeL1HttpTransport(rpcUrls: string[], opts?: { timeout?: number }) {
+  return fallback(rpcUrls.map(url => http(url, { batch: false, timeout: opts?.timeout })));
+}
+
 // TODO: Use these methods to abstract the creation of viem clients.
 
 /** Returns a viem public client given the L1 config. */
@@ -22,7 +43,7 @@ export function getPublicClient(config: Config): ViemPublicClient {
   const chain = createEthereumChain(config.l1RpcUrls, config.l1ChainId);
   return createPublicClient({
     chain: chain.chainInfo,
-    transport: fallback(config.l1RpcUrls.map(url => http(url))),
+    transport: makeL1HttpTransport(config.l1RpcUrls, { timeout: config.l1HttpTimeoutMS }),
     pollingInterval: config.viemPollingIntervalMS,
   });
 }
@@ -40,7 +61,7 @@ async function waitForRpc(client: ViemPublicClient, config: Config, logger?: Log
       let chainId = 0;
       try {
         chainId = await client.getChainId();
-      } catch (err) {
+      } catch {
         logger?.warn(`Failed to connect to Ethereum node at ${config.l1RpcUrls.join(', ')}. Retrying...`);
       }
       return chainId;
@@ -56,3 +77,28 @@ async function waitForRpc(client: ViemPublicClient, config: Config, logger?: Log
     );
   }
 }
+
+export function createExtendedL1Client(
+  rpcUrls: string[],
+  mnemonicOrPrivateKeyOrHdAccount: string | HDAccount | PrivateKeyAccount | LocalAccount,
+  chain: Chain = foundry,
+  pollingIntervalMS?: number,
+  addressIndex?: number,
+  opts?: { httpTimeoutMS?: number },
+): ExtendedViemWalletClient {
+  const hdAccount =
+    typeof mnemonicOrPrivateKeyOrHdAccount === 'string'
+      ? mnemonicOrPrivateKeyOrHdAccount.startsWith('0x')
+        ? privateKeyToAccount(mnemonicOrPrivateKeyOrHdAccount as `0x${string}`)
+        : mnemonicToAccount(mnemonicOrPrivateKeyOrHdAccount, { addressIndex })
+      : mnemonicOrPrivateKeyOrHdAccount;
+
+  const extendedClient = createWalletClient({
+    account: hdAccount,
+    chain,
+    transport: makeL1HttpTransport(rpcUrls, { timeout: opts?.httpTimeoutMS }),
+    pollingInterval: pollingIntervalMS,
+  }).extend(publicActions);
+
+  return extendedClient;
+}

package/src/config.ts

@@ -1,11 +1,27 @@
 import {
   type ConfigMappingsType,
   bigintConfigHelper,
+  booleanConfigHelper,
+  enumConfigHelper,
   getConfigFromMappings,
+  getDefaultConfig,
   numberConfigHelper,
+  omitConfigMappings,
+  optionalNumberConfigHelper,
 } from '@aztec/foundation/config';
+import { EthAddress } from '@aztec/foundation/eth-address';
 
-import { type L1TxUtilsConfig, l1TxUtilsConfigMappings } from './l1_tx_utils.js';
+import { l1ContractsDefaultEnv } from './generated/l1-contracts-defaults.js';
+import { type L1TxUtilsConfig, l1TxUtilsConfigMappings } from './l1_tx_utils/config.js';
+
+export type GenesisStateConfig = {
+  /** Whether to populate the genesis state with initial fee juice for the test accounts */
+  testAccounts: boolean;
+  /** Whether to populate the genesis state with initial fee juice for the sponsored FPC */
+  sponsoredFPC: boolean;
+  /** Additional addresses to prefund with fee juice at genesis */
+  prefundAddresses: string[];
+};
 
 export type L1ContractsConfig = {
   /** How many seconds an L1 slot lasts. */
@@ -16,88 +32,251 @@ export type L1ContractsConfig = {
   aztecEpochDuration: number;
   /** The target validator committee size. */
   aztecTargetCommitteeSize: number;
-  /** The number of L2 slots that we can wait for a proof of an epoch to be produced. */
-  aztecProofSubmissionWindow: number;
+  /** The number of epochs to lag behind the current epoch for validator selection. */
+  lagInEpochsForValidatorSet: number;
+  /** The number of epochs to lag behind the current epoch for randao selection. */
+  lagInEpochsForRandao: number;
+  /** The number of checkpoints to lag in the inbox (prevents sequencer DOS attacks). */
+  inboxLag: number;
+  /** The number of epochs after an epoch ends that proofs are still accepted. */
+  aztecProofSubmissionEpochs: number;
+  /** The deposit amount for a validator */
+  activationThreshold: bigint;
   /** The minimum stake for a validator. */
-  minimumStake: bigint;
-  /** The slashing quorum */
-  slashingQuorum: number;
-  /** The slashing round size */
-  slashingRoundSize: number;
-  /** Governance proposing quorum */
-  governanceProposerQuorum: number;
+  ejectionThreshold: bigint;
+  /** The local ejection threshold for a validator. Stricter than ejectionThreshold but local to a specific rollup */
+  localEjectionThreshold: bigint;
+  /** The slashing quorum, i.e. how many slots must signal for the same payload in a round for it to be submittable to the Slasher (defaults to slashRoundSize / 2 + 1) */
+  slashingQuorum?: number;
+  /** The slashing round size, i.e. how many epochs are in a slashing round */
+  slashingRoundSizeInEpochs: number;
+  /** The slashing lifetime in rounds. I.e., if 1, round N must be submitted before round N + 2 */
+  slashingLifetimeInRounds: number;
+  /** The slashing execution delay in rounds. I.e., if 1, round N may not be submitted until round N + 2 */
+  slashingExecutionDelayInRounds: number;
+  /** The slashing vetoer. May blacklist a payload from being submitted. */
+  slashingVetoer: EthAddress;
+  /** How many slashing rounds back we slash (ie when slashing in round N, we slash for offenses committed during epochs of round N-offset) */
+  slashingOffsetInRounds: number;
+  /** How long slashing can be disabled for in seconds when vetoer disables it */
+  slashingDisableDuration: number;
+  /** Type of slasher proposer */
+  slasherFlavor: 'empire' | 'tally' | 'none';
+  /** Minimum amount that can be slashed in tally slashing */
+  slashAmountSmall: bigint;
+  /** Medium amount to slash in tally slashing */
+  slashAmountMedium: bigint;
+  /** Largest amount that can be slashed per round in tally slashing */
+  slashAmountLarge: bigint;
+  /** Governance proposing quorum (defaults to roundSize/2 + 1) */
+  governanceProposerQuorum?: number;
   /** Governance proposing round size */
   governanceProposerRoundSize: number;
+  /** Governance voting duration in seconds (only for local/devnet/next-net, default 3600) */
+  governanceVotingDuration?: number;
+  /** The mana target for the rollup */
+  manaTarget: bigint;
+  /** The proving cost per mana */
+  provingCostPerMana: bigint;
+  /** The initial ETH per fee asset price (with 1e12 precision) */
+  initialEthPerFeeAsset: bigint;
+  /** The number of seconds to wait for an exit */
+  exitDelaySeconds: number;
 } & L1TxUtilsConfig;
 
-export const DefaultL1ContractsConfig = {
-  ethereumSlotDuration: 12,
-  aztecSlotDuration: 24,
-  aztecEpochDuration: 16,
-  aztecTargetCommitteeSize: 48,
-  aztecProofSubmissionWindow: 31, // you have a full epoch to submit a proof after the epoch to prove ends
-  minimumStake: BigInt(100e18),
-  slashingQuorum: 6,
-  slashingRoundSize: 10,
-  governanceProposerQuorum: 6,
-  governanceProposerRoundSize: 10,
-} satisfies L1ContractsConfig;
-
+/**
+ * Config mappings for L1ContractsConfig.
+ * Default values come from generated l1-contracts-defaults.json (source: defaults.yml).
+ * Real deployments use forge scripts which require explicit env vars (vm.envUint).
+ */
 export const l1ContractsConfigMappings: ConfigMappingsType<L1ContractsConfig> = {
   ethereumSlotDuration: {
     env: 'ETHEREUM_SLOT_DURATION',
     description: 'How many seconds an L1 slot lasts.',
-    ...numberConfigHelper(DefaultL1ContractsConfig.ethereumSlotDuration),
+    ...numberConfigHelper(l1ContractsDefaultEnv.ETHEREUM_SLOT_DURATION),
   },
   aztecSlotDuration: {
     env: 'AZTEC_SLOT_DURATION',
     description: 'How many seconds an L2 slots lasts (must be multiple of ethereum slot duration).',
-    ...numberConfigHelper(DefaultL1ContractsConfig.aztecSlotDuration),
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_SLOT_DURATION),
   },
   aztecEpochDuration: {
     env: 'AZTEC_EPOCH_DURATION',
-    description: `How many L2 slots an epoch lasts (maximum AZTEC_MAX_EPOCH_DURATION).`,
-    ...numberConfigHelper(DefaultL1ContractsConfig.aztecEpochDuration),
+    description: `How many L2 slots an epoch lasts (maximum MAX_CHECKPOINTS_PER_EPOCH).`,
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_EPOCH_DURATION),
   },
   aztecTargetCommitteeSize: {
     env: 'AZTEC_TARGET_COMMITTEE_SIZE',
     description: 'The target validator committee size.',
-    ...numberConfigHelper(DefaultL1ContractsConfig.aztecTargetCommitteeSize),
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_TARGET_COMMITTEE_SIZE),
   },
-  aztecProofSubmissionWindow: {
-    env: 'AZTEC_PROOF_SUBMISSION_WINDOW',
-    description:
-      'The number of L2 slots that a proof for an epoch can be submitted in, starting from the beginning of the epoch.',
-    ...numberConfigHelper(DefaultL1ContractsConfig.aztecProofSubmissionWindow),
+  lagInEpochsForValidatorSet: {
+    env: 'AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET',
+    description: 'The number of epochs to lag behind the current epoch for validator selection.',
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET),
+  },
+  lagInEpochsForRandao: {
+    env: 'AZTEC_LAG_IN_EPOCHS_FOR_RANDAO',
+    description: 'The number of epochs to lag behind the current epoch for randao selection.',
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_LAG_IN_EPOCHS_FOR_RANDAO),
   },
-  minimumStake: {
-    env: 'AZTEC_MINIMUM_STAKE',
+  inboxLag: {
+    env: 'AZTEC_INBOX_LAG',
+    description: 'The number of checkpoints to lag in the inbox (prevents sequencer DOS attacks).',
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_INBOX_LAG),
+  },
+  aztecProofSubmissionEpochs: {
+    env: 'AZTEC_PROOF_SUBMISSION_EPOCHS',
+    description: 'The number of epochs after an epoch ends that proofs are still accepted.',
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_PROOF_SUBMISSION_EPOCHS),
+  },
+  activationThreshold: {
+    env: 'AZTEC_ACTIVATION_THRESHOLD',
+    description: 'The deposit amount for a validator',
+    ...bigintConfigHelper(BigInt(l1ContractsDefaultEnv.AZTEC_ACTIVATION_THRESHOLD)),
+  },
+  ejectionThreshold: {
+    env: 'AZTEC_EJECTION_THRESHOLD',
     description: 'The minimum stake for a validator.',
-    ...bigintConfigHelper(DefaultL1ContractsConfig.minimumStake),
+    ...bigintConfigHelper(BigInt(l1ContractsDefaultEnv.AZTEC_EJECTION_THRESHOLD)),
+  },
+  localEjectionThreshold: {
+    env: 'AZTEC_LOCAL_EJECTION_THRESHOLD',
+    description:
+      'The local ejection threshold for a validator. Stricter than ejectionThreshold but local to a specific rollup',
+    ...bigintConfigHelper(BigInt(l1ContractsDefaultEnv.AZTEC_LOCAL_EJECTION_THRESHOLD)),
+  },
+  slashingOffsetInRounds: {
+    env: 'AZTEC_SLASHING_OFFSET_IN_ROUNDS',
+    description:
+      'How many slashing rounds back we slash (ie when slashing in round N, we slash for offenses committed during epochs of round N-offset)',
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_SLASHING_OFFSET_IN_ROUNDS),
+  },
+  slasherFlavor: {
+    env: 'AZTEC_SLASHER_FLAVOR',
+    description: 'Type of slasher proposer (empire, tally, or none)',
+    ...enumConfigHelper(
+      ['empire', 'tally', 'none'] as const,
+      l1ContractsDefaultEnv.AZTEC_SLASHER_FLAVOR as 'empire' | 'tally' | 'none',
+    ),
+  },
+  slashAmountSmall: {
+    env: 'AZTEC_SLASH_AMOUNT_SMALL',
+    description: 'Small slashing amount for light offenses',
+    ...bigintConfigHelper(BigInt(l1ContractsDefaultEnv.AZTEC_SLASH_AMOUNT_SMALL)),
+  },
+  slashAmountMedium: {
+    env: 'AZTEC_SLASH_AMOUNT_MEDIUM',
+    description: 'Medium slashing amount for moderate offenses',
+    ...bigintConfigHelper(BigInt(l1ContractsDefaultEnv.AZTEC_SLASH_AMOUNT_MEDIUM)),
+  },
+  slashAmountLarge: {
+    env: 'AZTEC_SLASH_AMOUNT_LARGE',
+    description: 'Large slashing amount for severe offenses',
+    ...bigintConfigHelper(BigInt(l1ContractsDefaultEnv.AZTEC_SLASH_AMOUNT_LARGE)),
   },
   slashingQuorum: {
     env: 'AZTEC_SLASHING_QUORUM',
     description: 'The slashing quorum',
-    ...numberConfigHelper(DefaultL1ContractsConfig.slashingQuorum),
+    ...optionalNumberConfigHelper(),
   },
-  slashingRoundSize: {
-    env: 'AZTEC_SLASHING_ROUND_SIZE',
+  slashingRoundSizeInEpochs: {
+    env: 'AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS',
     description: 'The slashing round size',
-    ...numberConfigHelper(DefaultL1ContractsConfig.slashingRoundSize),
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_SLASHING_ROUND_SIZE_IN_EPOCHS),
+  },
+  slashingLifetimeInRounds: {
+    env: 'AZTEC_SLASHING_LIFETIME_IN_ROUNDS',
+    description: 'The slashing lifetime in rounds',
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_SLASHING_LIFETIME_IN_ROUNDS),
+  },
+  slashingExecutionDelayInRounds: {
+    env: 'AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS',
+    description: 'The slashing execution delay in rounds',
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_SLASHING_EXECUTION_DELAY_IN_ROUNDS),
+  },
+  slashingVetoer: {
+    env: 'AZTEC_SLASHING_VETOER',
+    description: 'The slashing vetoer',
+    parseEnv: (val: string) => EthAddress.fromString(val),
+    defaultValue: EthAddress.fromString(l1ContractsDefaultEnv.AZTEC_SLASHING_VETOER),
+  },
+  slashingDisableDuration: {
+    env: 'AZTEC_SLASHING_DISABLE_DURATION',
+    description: 'How long slashing can be disabled for in seconds when vetoer disables it',
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_SLASHING_DISABLE_DURATION),
   },
   governanceProposerQuorum: {
     env: 'AZTEC_GOVERNANCE_PROPOSER_QUORUM',
     description: 'The governance proposing quorum',
-    ...numberConfigHelper(DefaultL1ContractsConfig.governanceProposerQuorum),
+    ...optionalNumberConfigHelper(),
   },
   governanceProposerRoundSize: {
     env: 'AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE',
     description: 'The governance proposing round size',
-    ...numberConfigHelper(DefaultL1ContractsConfig.governanceProposerRoundSize),
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_GOVERNANCE_PROPOSER_ROUND_SIZE),
+  },
+  governanceVotingDuration: {
+    env: 'AZTEC_GOVERNANCE_VOTING_DURATION',
+    description: 'Governance voting duration in seconds (only for local/devnet/next-net)',
+    ...numberConfigHelper(3600), // 1 hour default, not in generated defaults as it's deployment-time only
+  },
+  manaTarget: {
+    env: 'AZTEC_MANA_TARGET',
+    description: 'The mana target for the rollup',
+    ...bigintConfigHelper(BigInt(l1ContractsDefaultEnv.AZTEC_MANA_TARGET)),
+  },
+  provingCostPerMana: {
+    env: 'AZTEC_PROVING_COST_PER_MANA',
+    description: 'The proving cost per mana',
+    ...bigintConfigHelper(BigInt(l1ContractsDefaultEnv.AZTEC_PROVING_COST_PER_MANA)),
+  },
+  initialEthPerFeeAsset: {
+    env: 'AZTEC_INITIAL_ETH_PER_FEE_ASSET',
+    description: 'The initial ETH per fee asset price (with 1e12 precision)',
+    ...bigintConfigHelper(BigInt(l1ContractsDefaultEnv.AZTEC_INITIAL_ETH_PER_FEE_ASSET)),
+  },
+  exitDelaySeconds: {
+    env: 'AZTEC_EXIT_DELAY_SECONDS',
+    description: 'The delay before a validator can exit the set',
+    ...numberConfigHelper(l1ContractsDefaultEnv.AZTEC_EXIT_DELAY_SECONDS),
+  },
+  ...omitConfigMappings(l1TxUtilsConfigMappings, ['ethereumSlotDuration']),
+};
+
+/**
+ * Default L1 contracts configuration derived from l1ContractsConfigMappings.
+ * Source of truth: spartan/environments/defaults.yml -> defaults.l1-contracts
+ */
+export const DefaultL1ContractsConfig = getDefaultConfig(l1ContractsConfigMappings);
+
+export const genesisStateConfigMappings: ConfigMappingsType<GenesisStateConfig> = {
+  testAccounts: {
+    env: 'TEST_ACCOUNTS',
+    description: 'Whether to populate the genesis state with initial fee juice for the test accounts.',
+    ...booleanConfigHelper(false),
+  },
+  sponsoredFPC: {
+    env: 'SPONSORED_FPC',
+    description: 'Whether to populate the genesis state with initial fee juice for the sponsored FPC.',
+    ...booleanConfigHelper(false),
+  },
+  prefundAddresses: {
+    env: 'PREFUND_ADDRESSES',
+    description: 'Comma-separated list of Aztec addresses to prefund with fee juice at genesis (local network only).',
+    parseEnv: (val: string) =>
+      val
+        .split(',')
+        .map(a => a.trim())
+        .filter(a => a.length > 0),
+    defaultValue: [],
   },
-  ...l1TxUtilsConfigMappings,
 };
 
 export function getL1ContractsConfigEnvVars(): L1ContractsConfig {
   return getConfigFromMappings(l1ContractsConfigMappings);
 }
+
+export function getGenesisStateConfigEnvVars(): GenesisStateConfig {
+  return getConfigFromMappings(genesisStateConfigMappings);
+}

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

@@ -1,19 +1,91 @@
+import type { SlotNumber } from '@aztec/foundation/branded-types';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { Signature } from '@aztec/foundation/eth-signature';
 import { EmpireBaseAbi } from '@aztec/l1-artifacts/EmpireBaseAbi';
 
-import { type Hex, encodeFunctionData } from 'viem';
+import { type Hex, type TypedDataDefinition, encodeFunctionData } from 'viem';
 
-import type { L1TxRequest } from '../l1_tx_utils.js';
+import type { L1TxRequest } from '../l1_tx_utils/index.js';
 
 export interface IEmpireBase {
-  getRoundInfo(rollupAddress: Hex, round: bigint): Promise<{ lastVote: bigint; leader: Hex; executed: boolean }>;
-  computeRound(slot: bigint): Promise<bigint>;
-  createVoteRequest(payload: Hex): L1TxRequest;
+  get address(): EthAddress;
+  getRoundInfo(
+    rollupAddress: Hex,
+    round: bigint,
+  ): Promise<{ lastSignalSlot: SlotNumber; payloadWithMostSignals: Hex; quorumReached: boolean; executed: boolean }>;
+  computeRound(slot: SlotNumber): Promise<bigint>;
+  createSignalRequest(payload: Hex): L1TxRequest;
+  createSignalRequestWithSignature(
+    payload: Hex,
+    slot: SlotNumber,
+    chainId: number,
+    signerAddress: Hex,
+    signer: (msg: TypedDataDefinition) => Promise<Hex>,
+  ): Promise<L1TxRequest>;
+  /** Checks if a payload was ever submitted to governance via submitRoundWinner. */
+  hasPayloadBeenProposed(payload: Hex, fromBlock: bigint): Promise<boolean>;
 }
 
-export function encodeVote(payload: Hex): Hex {
+export function encodeSignal(payload: Hex): Hex {
   return encodeFunctionData({
     abi: EmpireBaseAbi,
-    functionName: 'vote',
+    functionName: 'signal',
     args: [payload],
   });
 }
+
+export function encodeSignalWithSignature(payload: Hex, signature: Signature) {
+  return encodeFunctionData({
+    abi: EmpireBaseAbi,
+    functionName: 'signalWithSig',
+    args: [payload, signature.toViemSignature()],
+  });
+}
+
+/**
+ * Signs a signal proposal using EIP-712 typed data for use with signalWithSig
+ * @param walletClient - The viem wallet client to sign with
+ * @param payload - The payload address to signal
+ * @param verifyingContract - The address of the EmpireBase contract
+ * @param chainId - The chain ID where the contract is deployed
+ * @param account - The account to sign with (optional if hoisted on wallet client)
+ * @returns The EIP-712 signature
+ */
+export async function signSignalWithSig(
+  signer: (msg: TypedDataDefinition) => Promise<Hex>,
+  payload: Hex,
+  slot: SlotNumber,
+  instance: Hex,
+  verifyingContract: Hex,
+  chainId: number,
+): Promise<Signature> {
+  const domain = {
+    name: 'EmpireBase',
+    version: '1',
+    chainId,
+    verifyingContract,
+  };
+
+  const types = {
+    EIP712Domain: [
+      { name: 'name', type: 'string' },
+      { name: 'version', type: 'string' },
+      { name: 'chainId', type: 'uint256' },
+      { name: 'verifyingContract', type: 'address' },
+    ],
+    Signal: [
+      { name: 'payload', type: 'address' },
+      { name: 'slot', type: 'uint256' },
+      { name: 'instance', type: 'address' },
+    ],
+  };
+
+  const message = {
+    payload,
+    slot: BigInt(slot),
+    instance,
+  };
+
+  const typedData = { domain, types, primaryType: 'Signal', message };
+  return Signature.fromString(await signer(typedData));
+}