@aztec/ethereum 0.0.0-test.1 → 0.0.1-commit.017a351

package/src/l1_artifacts.ts

@@ -0,0 +1,231 @@
+import {
+  CoinIssuerAbi,
+  CoinIssuerBytecode,
+  DateGatedRelayerAbi,
+  DateGatedRelayerBytecode,
+  FeeAssetHandlerAbi,
+  FeeAssetHandlerBytecode,
+  FeeJuicePortalAbi,
+  FeeJuicePortalBytecode,
+  GSEAbi,
+  GSEBytecode,
+  GovernanceAbi,
+  GovernanceBytecode,
+  GovernanceProposerAbi,
+  GovernanceProposerBytecode,
+  HonkVerifierAbi,
+  HonkVerifierBytecode,
+  InboxAbi,
+  InboxBytecode,
+  MockVerifierAbi,
+  MockVerifierBytecode,
+  MockZKPassportVerifierAbi,
+  MockZKPassportVerifierBytecode,
+  MultiAdderAbi,
+  MultiAdderBytecode,
+  OutboxAbi,
+  OutboxBytecode,
+  RegisterNewRollupVersionPayloadAbi,
+  RegisterNewRollupVersionPayloadBytecode,
+  RegistryAbi,
+  RegistryBytecode,
+  RewardDistributorAbi,
+  RewardDistributorBytecode,
+  RewardExtLibAbi,
+  RewardExtLibBytecode,
+  RollupAbi,
+  RollupBytecode,
+  RollupLinkReferences,
+  RollupOperationsExtLibAbi,
+  RollupOperationsExtLibBytecode,
+  SlasherAbi,
+  SlasherBytecode,
+  SlasherDeploymentExtLibAbi,
+  SlasherDeploymentExtLibBytecode,
+  SlashingProposerAbi,
+  SlashingProposerBytecode,
+  StakingAssetHandlerAbi,
+  StakingAssetHandlerBytecode,
+  TestERC20Abi,
+  TestERC20Bytecode,
+  ValidatorOperationsExtLibAbi,
+  ValidatorOperationsExtLibBytecode,
+  ValidatorSelectionLibAbi,
+  ValidatorSelectionLibBytecode,
+} from '@aztec/l1-artifacts';
+
+import type { Hex } from 'viem';
+
+export const RegistryArtifact = {
+  name: 'Registry',
+  contractAbi: RegistryAbi,
+  contractBytecode: RegistryBytecode as Hex,
+};
+
+export const InboxArtifact = {
+  name: 'Inbox',
+  contractAbi: InboxAbi,
+  contractBytecode: InboxBytecode as Hex,
+};
+
+export const OutboxArtifact = {
+  name: 'Outbox',
+  contractAbi: OutboxAbi,
+  contractBytecode: OutboxBytecode as Hex,
+};
+
+export const RollupArtifact = {
+  name: 'Rollup',
+  contractAbi: RollupAbi,
+  contractBytecode: RollupBytecode as Hex,
+  libraries: {
+    linkReferences: RollupLinkReferences,
+    libraryCode: {
+      ValidatorSelectionLib: {
+        name: 'ValidatorSelectionLib',
+        contractAbi: ValidatorSelectionLibAbi,
+        contractBytecode: ValidatorSelectionLibBytecode as Hex,
+      },
+      RollupOperationsExtLib: {
+        name: 'RollupOperationsExtLib',
+        contractAbi: RollupOperationsExtLibAbi,
+        contractBytecode: RollupOperationsExtLibBytecode as Hex,
+      },
+      ValidatorOperationsExtLib: {
+        name: 'ValidatorOperationsExtLib',
+        contractAbi: ValidatorOperationsExtLibAbi,
+        contractBytecode: ValidatorOperationsExtLibBytecode as Hex,
+      },
+      RewardExtLib: {
+        name: 'RewardExtLib',
+        contractAbi: RewardExtLibAbi,
+        contractBytecode: RewardExtLibBytecode as Hex,
+      },
+      SlasherDeploymentExtLib: {
+        name: 'SlasherDeploymentExtLib',
+        contractAbi: SlasherDeploymentExtLibAbi,
+        contractBytecode: SlasherDeploymentExtLibBytecode as Hex,
+      },
+    },
+  },
+};
+
+export const StakingAssetArtifact = {
+  name: 'StakingAsset',
+  contractAbi: TestERC20Abi,
+  contractBytecode: TestERC20Bytecode as Hex,
+};
+
+export const FeeAssetArtifact = {
+  name: 'FeeAsset',
+  contractAbi: TestERC20Abi,
+  contractBytecode: TestERC20Bytecode as Hex,
+};
+
+export const FeeJuicePortalArtifact = {
+  name: 'FeeJuicePortal',
+  contractAbi: FeeJuicePortalAbi,
+  contractBytecode: FeeJuicePortalBytecode as Hex,
+};
+
+export const RewardDistributorArtifact = {
+  name: 'RewardDistributor',
+  contractAbi: RewardDistributorAbi,
+  contractBytecode: RewardDistributorBytecode as Hex,
+};
+
+export const CoinIssuerArtifact = {
+  name: 'CoinIssuer',
+  contractAbi: CoinIssuerAbi,
+  contractBytecode: CoinIssuerBytecode as Hex,
+};
+
+export const DateGatedRelayerArtifact = {
+  name: 'DateGatedRelayer',
+  contractAbi: DateGatedRelayerAbi,
+  contractBytecode: DateGatedRelayerBytecode as Hex,
+};
+
+export const GovernanceProposerArtifact = {
+  name: 'GovernanceProposer',
+  contractAbi: GovernanceProposerAbi,
+  contractBytecode: GovernanceProposerBytecode as Hex,
+};
+
+export const GovernanceArtifact = {
+  name: 'Governance',
+  contractAbi: GovernanceAbi,
+  contractBytecode: GovernanceBytecode as Hex,
+};
+
+export const SlasherArtifact = {
+  name: 'Slasher',
+  contractAbi: SlasherAbi,
+  contractBytecode: SlasherBytecode as Hex,
+};
+
+export const SlashingProposerArtifact = {
+  name: 'SlashingProposer',
+  contractAbi: SlashingProposerAbi,
+  contractBytecode: SlashingProposerBytecode as Hex,
+};
+
+export const RegisterNewRollupVersionPayloadArtifact = {
+  name: 'RegisterNewRollupVersionPayload',
+  contractAbi: RegisterNewRollupVersionPayloadAbi,
+  contractBytecode: RegisterNewRollupVersionPayloadBytecode as Hex,
+};
+
+export const FeeAssetHandlerArtifact = {
+  name: 'FeeAssetHandler',
+  contractAbi: FeeAssetHandlerAbi,
+  contractBytecode: FeeAssetHandlerBytecode as Hex,
+};
+
+export const StakingAssetHandlerArtifact = {
+  name: 'StakingAssetHandler',
+  contractAbi: StakingAssetHandlerAbi,
+  contractBytecode: StakingAssetHandlerBytecode as Hex,
+};
+
+export const MultiAdderArtifact = {
+  name: 'MultiAdder',
+  contractAbi: MultiAdderAbi,
+  contractBytecode: MultiAdderBytecode as Hex,
+};
+
+export const GSEArtifact = {
+  name: 'GSE',
+  contractAbi: GSEAbi,
+  contractBytecode: GSEBytecode as Hex,
+};
+
+// Verifier artifacts
+export const HonkVerifierArtifact = {
+  name: 'HonkVerifier',
+  contractAbi: HonkVerifierAbi,
+  contractBytecode: HonkVerifierBytecode as Hex,
+};
+
+export const MockVerifierArtifact = {
+  name: 'MockVerifier',
+  contractAbi: MockVerifierAbi,
+  contractBytecode: MockVerifierBytecode as Hex,
+};
+
+export const MockZkPassportVerifierArtifact = {
+  name: 'MockZkPassportVerifier',
+  contractAbi: MockZKPassportVerifierAbi,
+  contractBytecode: MockZKPassportVerifierBytecode as Hex,
+};
+
+// Re-export the verifier artifacts for backwards compatibility
+export const l1ArtifactsVerifiers = {
+  honkVerifier: HonkVerifierArtifact,
+};
+
+// Re-export the mock verifiers for backwards compatibility
+export const mockVerifiers = {
+  mockVerifier: MockVerifierArtifact,
+  mockZkPassportVerifier: MockZkPassportVerifierArtifact,
+};

package/src/l1_contract_addresses.ts

@@ -1,15 +1,15 @@
-import type { ConfigMappingsType } from '@aztec/foundation/config';
+import type { ConfigMapping, ConfigMappingsType } from '@aztec/foundation/config';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { type ZodFor, schemas } from '@aztec/foundation/schemas';
+import { schemas } from '@aztec/foundation/schemas';
 
 import { z } from 'zod';
 
 /**
- * The names of the current L1 contract addresses.
+ * Required L1 contract address keys.
  * NOTE: When changing this list, make sure to update CLI & CI scripts accordingly.
  * For reference: https://github.com/AztecProtocol/aztec-packages/pull/5553
  */
-export const L1ContractsNames = [
+const REQUIRED_L1_CONTRACT_ADDRESS_KEYS = [
   'rollupAddress',
   'registryAddress',
   'inboxAddress',
@@ -23,87 +23,128 @@ export const L1ContractsNames = [
   'stakingAssetAddress',
 ] as const;
 
+/** Optional L1 contract address keys — present only in some deployments. */
+export const OPTIONAL_L1_CONTRACT_ADDRESS_KEYS = [
+  'feeAssetHandlerAddress',
+  'stakingAssetHandlerAddress',
+  'zkPassportVerifierAddress',
+  'gseAddress',
+  'dateGatedRelayerAddress',
+] as const;
+
+type RequiredContractKey = (typeof REQUIRED_L1_CONTRACT_ADDRESS_KEYS)[number];
+type OptionalContractKey = (typeof OPTIONAL_L1_CONTRACT_ADDRESS_KEYS)[number];
+
 /** Provides the directory of current L1 contract addresses */
 export type L1ContractAddresses = {
-  [K in (typeof L1ContractsNames)[number]]: EthAddress;
-} & { slashFactoryAddress?: EthAddress | undefined };
+  [K in RequiredContractKey]: EthAddress;
+} & {
+  [K in OptionalContractKey]?: EthAddress;
+};
 
-export const L1ContractAddressesSchema = z.object({
-  rollupAddress: schemas.EthAddress,
-  registryAddress: schemas.EthAddress,
-  inboxAddress: schemas.EthAddress,
-  outboxAddress: schemas.EthAddress,
-  feeJuiceAddress: schemas.EthAddress,
-  stakingAssetAddress: schemas.EthAddress,
-  feeJuicePortalAddress: schemas.EthAddress,
-  coinIssuerAddress: schemas.EthAddress,
-  rewardDistributorAddress: schemas.EthAddress,
-  governanceProposerAddress: schemas.EthAddress,
-  governanceAddress: schemas.EthAddress,
-  slashFactoryAddress: schemas.EthAddress.optional(),
-}) satisfies ZodFor<L1ContractAddresses>;
+/**
+ * Names of required L1 contract addresses.
+ * NOTE: When changing the set of contracts, update CLI & CI scripts accordingly.
+ * For reference: https://github.com/AztecProtocol/aztec-packages/pull/5553
+ */
+export const L1ContractsNames = REQUIRED_L1_CONTRACT_ADDRESS_KEYS;
 
 const parseEnv = (val: string) => EthAddress.fromString(val);
+const addrEnv = (description: string, env?: ConfigMapping<EthAddress>['env']): ConfigMapping<EthAddress> => ({
+  description,
+  parseEnv,
+  ...(env && { env }),
+});
 
+/**
+ * Config mapping for all L1 contract addresses.
+ * This is the single source of truth for which contract addresses exist and how to parse them.
+ */
 export const l1ContractAddressesMapping: ConfigMappingsType<L1ContractAddresses> = {
-  rollupAddress: {
-    env: 'ROLLUP_CONTRACT_ADDRESS',
-    description: 'The deployed L1 rollup contract address.',
-    parseEnv,
-  },
-  registryAddress: {
-    env: 'REGISTRY_CONTRACT_ADDRESS',
-    description: 'The deployed L1 registry contract address.',
-    parseEnv,
-  },
-  inboxAddress: {
-    env: 'INBOX_CONTRACT_ADDRESS',
-    description: 'The deployed L1 inbox contract address.',
-    parseEnv,
-  },
-  outboxAddress: {
-    env: 'OUTBOX_CONTRACT_ADDRESS',
-    description: 'The deployed L1 outbox contract address.',
-    parseEnv,
-  },
-  feeJuiceAddress: {
-    env: 'FEE_JUICE_CONTRACT_ADDRESS',
-    description: 'The deployed L1 Fee Juice contract address.',
-    parseEnv,
-  },
-  stakingAssetAddress: {
-    env: 'STAKING_ASSET_CONTRACT_ADDRESS',
-    description: 'The deployed L1 staking asset contract address.',
-    parseEnv,
-  },
-  feeJuicePortalAddress: {
-    env: 'FEE_JUICE_PORTAL_CONTRACT_ADDRESS',
-    description: 'The deployed L1 Fee Juice portal contract address.',
-    parseEnv,
-  },
-  coinIssuerAddress: {
-    env: 'COIN_ISSUER_CONTRACT_ADDRESS',
-    description: 'The deployed L1 coinIssuer contract address',
-    parseEnv,
-  },
-  rewardDistributorAddress: {
-    env: 'REWARD_DISTRIBUTOR_CONTRACT_ADDRESS',
-    description: 'The deployed L1 rewardDistributor contract address',
-    parseEnv,
-  },
-  governanceProposerAddress: {
-    env: 'GOVERNANCE_PROPOSER_CONTRACT_ADDRESS',
-    description: 'The deployed L1 governanceProposer contract address',
-    parseEnv,
-  },
-  governanceAddress: {
-    env: 'GOVERNANCE_CONTRACT_ADDRESS',
-    description: 'The deployed L1 governance contract address',
-    parseEnv,
-  },
-  slashFactoryAddress: {
-    env: 'SLASH_FACTORY_CONTRACT_ADDRESS',
-    description: 'The deployed L1 slashFactory contract address',
-    parseEnv,
-  },
+  rollupAddress: addrEnv('The deployed L1 rollup contract address.'),
+  registryAddress: addrEnv('The deployed L1 registry contract address.', 'REGISTRY_CONTRACT_ADDRESS'),
+  inboxAddress: addrEnv('The deployed L1 inbox contract address.'),
+  outboxAddress: addrEnv('The deployed L1 outbox contract address.'),
+  feeJuiceAddress: addrEnv('The deployed L1 Fee Juice contract address.'),
+  feeJuicePortalAddress: addrEnv('The deployed L1 Fee Juice portal contract address.'),
+  coinIssuerAddress: addrEnv('The deployed L1 coinIssuer contract address'),
+  rewardDistributorAddress: addrEnv('The deployed L1 rewardDistributor contract address'),
+  governanceProposerAddress: addrEnv('The deployed L1 governanceProposer contract address'),
+  governanceAddress: addrEnv('The deployed L1 governance contract address'),
+  stakingAssetAddress: addrEnv('The deployed L1 staking asset contract address.'),
+  feeAssetHandlerAddress: addrEnv(
+    'The deployed L1 feeAssetHandler contract address',
+    'FEE_ASSET_HANDLER_CONTRACT_ADDRESS',
+  ),
+  stakingAssetHandlerAddress: addrEnv('The deployed L1 stakingAssetHandler contract address'),
+  zkPassportVerifierAddress: addrEnv('The deployed L1 ZK passport verifier contract address'),
+  gseAddress: addrEnv('The deployed L1 GSE contract address'),
+  dateGatedRelayerAddress: addrEnv('The deployed L1 date-gated relayer contract address'),
 };
+
+/** Keys present in {@link l1ContractAddressesMapping}. */
+export type L1ContractAddressMappingKey = keyof typeof l1ContractAddressesMapping;
+
+type RequiredAddressShape = { [K in RequiredContractKey]: typeof schemas.EthAddress };
+type OptionalAddressShape = { [K in OptionalContractKey]: ReturnType<typeof schemas.EthAddress.optional> };
+
+export const L1ContractAddressesSchema = z.object({
+  ...(Object.fromEntries(REQUIRED_L1_CONTRACT_ADDRESS_KEYS.map(k => [k, schemas.EthAddress])) as RequiredAddressShape),
+  ...(Object.fromEntries(
+    OPTIONAL_L1_CONTRACT_ADDRESS_KEYS.map(k => [k, schemas.EthAddress.optional()]),
+  ) as OptionalAddressShape),
+});
+
+/**
+ * Selects entries from {@link l1ContractAddressesMapping} so composed configs can reuse the same
+ * env vars, descriptions, and parsers without duplicating definitions.
+ *
+ * @example
+ * ```ts
+ * const mappings = {
+ *   ...pickL1ContractAddressMappings('rollupAddress'),
+ *   nodeId: { ... },
+ * };
+ * ```
+ */
+export function pickL1ContractAddressMappings<const K extends readonly L1ContractAddressMappingKey[]>(
+  ...keys: K
+): Pick<typeof l1ContractAddressesMapping, K[number]> {
+  return Object.fromEntries(keys.map(key => [key, l1ContractAddressesMapping[key]] as const)) as Pick<
+    typeof l1ContractAddressesMapping,
+    K[number]
+  >;
+}
+
+/**
+ * Like {@link pickL1ContractAddressMappings}, but returns a fragment of {@link L1ContractAddressesSchema}'s shape for
+ * spreading into `z.object({ ...pickL1ContractAddressesSchemaShape('rollupAddress'), localField: z... })`.
+ */
+export function pickL1ContractAddressesSchema<const K extends readonly L1ContractAddressMappingKey[]>(
+  ...keys: K
+): Pick<typeof L1ContractAddressesSchema.shape, K[number]> {
+  return Object.fromEntries(keys.map(key => [key, L1ContractAddressesSchema.shape[key]])) as Pick<
+    typeof L1ContractAddressesSchema.shape,
+    K[number]
+  >;
+}
+
+/** Builds an {@link L1ContractAddresses} object from config that stores those fields at the top level. */
+export function pickL1ContractAddresses<T extends L1ContractAddresses>(config: T): L1ContractAddresses {
+  const result: Partial<L1ContractAddresses> = {};
+  for (const key of REQUIRED_L1_CONTRACT_ADDRESS_KEYS) {
+    result[key] = config[key];
+  }
+  for (const key of OPTIONAL_L1_CONTRACT_ADDRESS_KEYS) {
+    const v = config[key];
+    if (v !== undefined) {
+      result[key] = v;
+    }
+  }
+  return result as L1ContractAddresses;
+}
+
+export function randomL1ContractAddresses(includeOptional: boolean = false): L1ContractAddresses {
+  const keys = includeOptional ? [...L1ContractsNames, ...OPTIONAL_L1_CONTRACT_ADDRESS_KEYS] : L1ContractsNames;
+  return Object.fromEntries(keys.map(name => [name, EthAddress.random()])) as L1ContractAddresses;
+}

package/src/l1_reader.ts

@@ -1,40 +1,55 @@
-import { type ConfigMappingsType, getConfigFromMappings, numberConfigHelper } from '@aztec/foundation/config';
+import {
+  type ConfigMappingsType,
+  getConfigFromMappings,
+  numberConfigHelper,
+  optionalNumberConfigHelper,
+} from '@aztec/foundation/config';
 
 import { type L1ContractAddresses, l1ContractAddressesMapping } from './l1_contract_addresses.js';
 
 /** Configuration of the L1GlobalReader. */
-export interface L1ReaderConfig {
-  /** The RPC Url of the ethereum host. */
+export type L1ReaderConfig = {
+  /** List of URLs of Ethereum RPC nodes that services will connect to (comma separated). */
   l1RpcUrls: string[];
+  /** The RPC Url of the ethereum debug host for trace and debug methods. */
+  l1DebugRpcUrls: string[];
   /** The chain ID of the ethereum host. */
   l1ChainId: number;
-  /** The deployed l1 contract addresses */
-  l1Contracts: L1ContractAddresses;
   /** The polling interval viem uses in ms */
   viemPollingIntervalMS: number;
-}
+  /** Timeout for HTTP requests to the L1 RPC node in ms. */
+  l1HttpTimeoutMS?: number;
+} & L1ContractAddresses;
 
 export const l1ReaderConfigMappings: ConfigMappingsType<L1ReaderConfig> = {
-  l1RpcUrls: {
-    env: 'ETHEREUM_HOSTS',
-    description: 'The RPC Url of the ethereum host.',
-    parseEnv: (val: string) => val.split(',').map(url => url.trim()),
-  },
   l1ChainId: {
     env: 'L1_CHAIN_ID',
-    parseEnv: (val: string) => +val,
-    defaultValue: 31337,
+    ...optionalNumberConfigHelper(),
     description: 'The chain ID of the ethereum host.',
   },
-  l1Contracts: {
-    description: 'The deployed L1 contract addresses',
-    nested: l1ContractAddressesMapping,
+  l1RpcUrls: {
+    env: 'ETHEREUM_HOSTS',
+    description: 'List of URLs of Ethereum RPC nodes that services will connect to (comma separated).',
+    parseEnv: (val: string) => val.split(',').map(url => url.trim()),
+    defaultValue: [],
+  },
+  l1DebugRpcUrls: {
+    env: 'ETHEREUM_DEBUG_HOSTS',
+    description: 'The RPC Url of the ethereum debug host for trace and debug methods.',
+    parseEnv: (val: string) => val.split(',').map(url => url.trim()),
+    defaultValue: [],
   },
   viemPollingIntervalMS: {
     env: 'L1_READER_VIEM_POLLING_INTERVAL_MS',
     description: 'The polling interval viem uses in ms',
     ...numberConfigHelper(1_000),
   },
+  l1HttpTimeoutMS: {
+    env: 'ETHEREUM_HTTP_TIMEOUT_MS',
+    description: 'Timeout for HTTP requests to the L1 RPC node in ms.',
+    ...optionalNumberConfigHelper(),
+  },
+  ...l1ContractAddressesMapping,
 };
 
 export function getL1ReaderConfigFromEnv(): L1ReaderConfig {