@aztec/ethereum 0.0.0-test.0

package/dest/eth_cheat_codes.d.ts

@@ -0,0 +1,147 @@
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import { type Hex } from 'viem';
+/**
+ * A class that provides utility functions for interacting with ethereum (L1).
+ */
+export declare class EthCheatCodes {
+    /**
+     * The RPC URL to use for interacting with the chain
+     */
+    rpcUrls: string[];
+    /**
+     * The logger to use for the eth cheatcodes
+     */
+    logger: import("@aztec/foundation/log").Logger;
+    private publicClient;
+    constructor(
+    /**
+     * The RPC URL to use for interacting with the chain
+     */
+    rpcUrls: string[], 
+    /**
+     * The logger to use for the eth cheatcodes
+     */
+    logger?: import("@aztec/foundation/log").Logger);
+    rpcCall(method: string, params: any[]): Promise<any>;
+    /**
+     * Get the auto mine status of the underlying chain
+     * @returns True if automine is on, false otherwise
+     */
+    isAutoMining(): Promise<boolean>;
+    /**
+     * Get the current blocknumber
+     * @returns The current block number
+     */
+    blockNumber(): Promise<number>;
+    /**
+     * Get the current chainId
+     * @returns The current chainId
+     */
+    chainId(): Promise<number>;
+    /**
+     * Get the current timestamp
+     * @returns The current timestamp
+     */
+    timestamp(): Promise<number>;
+    /**
+     * Advance the chain by a number of blocks
+     * @param numberOfBlocks - The number of blocks to mine
+     */
+    mine(numberOfBlocks?: number): Promise<void>;
+    private doMine;
+    /**
+     * Mines a single block with evm_mine
+     */
+    evmMine(): Promise<void>;
+    /**
+     * Set the balance of an account
+     * @param account - The account to set the balance for
+     * @param balance - The balance to set
+     */
+    setBalance(account: EthAddress, balance: bigint): Promise<void>;
+    /**
+     * Set the interval between blocks (block time)
+     * @param interval - The interval to use between blocks
+     */
+    setBlockInterval(interval: number): Promise<void>;
+    /**
+     * Set the next block base fee per gas
+     * @param baseFee - The base fee to set
+     */
+    setNextBlockBaseFeePerGas(baseFee: bigint | number): Promise<void>;
+    /**
+     * Set the interval between blocks (block time)
+     * @param seconds - The interval to use between blocks
+     */
+    setIntervalMining(seconds: number): Promise<void>;
+    /**
+     * Set the automine status of the underlying anvil chain
+     * @param automine - The automine status to set
+     */
+    setAutomine(automine: boolean): Promise<void>;
+    /**
+     * Drop a transaction from the mempool
+     * @param txHash - The transaction hash
+     */
+    dropTransaction(txHash: Hex): Promise<void>;
+    /**
+     * Set the next block timestamp
+     * @param timestamp - The timestamp to set the next block to
+     */
+    setNextBlockTimestamp(timestamp: number): Promise<void>;
+    /**
+     * Set the next block timestamp and mines the block
+     * @param timestamp - The timestamp to set the next block to
+     */
+    warp(timestamp: number | bigint, silent?: boolean): Promise<void>;
+    /**
+     * Load the value at a storage slot of a contract address on eth
+     * @param contract - The contract address
+     * @param slot - The storage slot
+     * @returns - The value at the storage slot
+     */
+    load(contract: EthAddress, slot: bigint): Promise<bigint>;
+    /**
+     * Set the value at a storage slot of a contract address on eth
+     * @param contract - The contract address
+     * @param slot - The storage slot
+     * @param value - The value to set the storage slot to
+     */
+    store(contract: EthAddress, slot: bigint, value: bigint): Promise<void>;
+    /**
+     * Computes the slot value for a given map and key.
+     * @param baseSlot - The base slot of the map (specified in Aztec.nr contract)
+     * @param key - The key to lookup in the map
+     * @returns The storage slot of the value in the map
+     */
+    keccak256(baseSlot: bigint, key: bigint): bigint;
+    /**
+     * Send transactions impersonating an externally owned account or contract.
+     * @param who - The address to impersonate
+     */
+    startImpersonating(who: EthAddress | Hex): Promise<void>;
+    /**
+     * Stop impersonating an account that you are currently impersonating.
+     * @param who - The address to stop impersonating
+     */
+    stopImpersonating(who: EthAddress | Hex): Promise<void>;
+    /**
+     * Set the bytecode for a contract
+     * @param contract - The contract address
+     * @param bytecode - The bytecode to set
+     */
+    etch(contract: EthAddress, bytecode: `0x${string}`): Promise<void>;
+    /**
+     * Get the bytecode for a contract
+     * @param contract - The contract address
+     * @returns The bytecode for the contract
+     */
+    getBytecode(contract: EthAddress): Promise<`0x${string}`>;
+    /**
+     * Get the raw transaction object for a given transaction hash
+     * @param txHash - The transaction hash
+     * @returns The raw transaction
+     */
+    getRawTransaction(txHash: Hex): Promise<`0x${string}`>;
+}
+//# sourceMappingURL=eth_cheat_codes.d.ts.map

package/dest/eth_cheat_codes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eth_cheat_codes.d.ts","sourceRoot":"","sources":["../src/eth_cheat_codes.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAGhE,OAAO,EAAE,KAAK,GAAG,EAAsC,MAAM,MAAM,CAAC;AAIpE;;GAEG;AACH,qBAAa,aAAa;IAGtB;;OAEG;IACI,OAAO,EAAE,MAAM,EAAE;IACxB;;OAEG;IACI,MAAM;IATf,OAAO,CAAC,YAAY,CAAmB;;IAErC;;OAEG;IACI,OAAO,EAAE,MAAM,EAAE;IACxB;;OAEG;IACI,MAAM,yCAAuC;IAOhD,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE;IAS3C;;;OAGG;IACU,YAAY,IAAI,OAAO,CAAC,OAAO,CAAC;IAU7C;;;OAGG;IACU,WAAW,IAAI,OAAO,CAAC,MAAM,CAAC;IAK3C;;;OAGG;IACU,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC;IAKvC;;;OAGG;IACU,SAAS,IAAI,OAAO,CAAC,MAAM,CAAC;IAKzC;;;OAGG;IACU,IAAI,CAAC,cAAc,SAAI,GAAG,OAAO,CAAC,IAAI,CAAC;YAKtC,MAAM;IAQpB;;OAEG;IACU,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAQrC;;;;OAIG;IACU,UAAU,CAAC,OAAO,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAS5E;;;OAGG;IACU,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAS9D;;;OAGG;IACU,yBAAyB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAS/E;;;OAGG;IACU,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAS9D;;;OAGG;IACU,WAAW,CAAC,QAAQ,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAS1D;;;OAGG;IACU,eAAe,CAAC,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IASxD;;;OAGG;IACU,qBAAqB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IASpE;;;OAGG;IACU,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE,MAAM,UAAQ,GAAG,OAAO,CAAC,IAAI,CAAC;IAY5E;;;;;OAKG;IACU,IAAI,CAAC,QAAQ,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAKtE;;;;;OAKG;IACU,KAAK,CAAC,QAAQ,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAUpF;;;;;OAKG;IACI,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM;IAMvD;;;OAGG;IACU,kBAAkB,CAAC,GAAG,EAAE,UAAU,GAAG,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IASrE;;;OAGG;IACU,iBAAiB,CAAC,GAAG,EAAE,UAAU,GAAG,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IASpE;;;;OAIG;IACU,IAAI,CAAC,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,KAAK,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAS/E;;;;OAIG;IACU,WAAW,CAAC,QAAQ,EAAE,UAAU,GAAG,OAAO,CAAC,KAAK,MAAM,EAAE,CAAC;IAKtE;;;;OAIG;IACU,iBAAiB,CAAC,MAAM,EAAE,GAAG,GAAG,OAAO,CAAC,KAAK,MAAM,EAAE,CAAC;CAIpE"}

package/dest/eth_cheat_codes.js

@@ -0,0 +1,303 @@
+import { toBigIntBE, toHex } from '@aztec/foundation/bigint-buffer';
+import { keccak256 } from '@aztec/foundation/crypto';
+import { createLogger } from '@aztec/foundation/log';
+import { createPublicClient, fallback, http } from 'viem';
+/**
+ * A class that provides utility functions for interacting with ethereum (L1).
+ */ export class EthCheatCodes {
+    rpcUrls;
+    logger;
+    publicClient;
+    constructor(/**
+     * The RPC URL to use for interacting with the chain
+     */ rpcUrls, /**
+     * The logger to use for the eth cheatcodes
+     */ logger = createLogger('ethereum:cheat_codes')){
+        this.rpcUrls = rpcUrls;
+        this.logger = logger;
+        this.publicClient = createPublicClient({
+            transport: fallback(this.rpcUrls.map((url)=>http(url)))
+        });
+    }
+    async rpcCall(method, params) {
+        const paramsString = JSON.stringify(params);
+        this.logger.info(`Calling ${method} with params: ${paramsString} on ${this.rpcUrls.join(', ')}`);
+        return await this.publicClient.transport.request({
+            method,
+            params
+        });
+    }
+    /**
+   * Get the auto mine status of the underlying chain
+   * @returns True if automine is on, false otherwise
+   */ async isAutoMining() {
+        try {
+            const res = await this.rpcCall('anvil_getAutomine', []);
+            return res;
+        } catch (err) {
+            this.logger.error(`Calling "anvil_getAutomine" failed with:`, err);
+        }
+        return false;
+    }
+    /**
+   * Get the current blocknumber
+   * @returns The current block number
+   */ async blockNumber() {
+        const res = await this.rpcCall('eth_blockNumber', []);
+        return parseInt(res, 16);
+    }
+    /**
+   * Get the current chainId
+   * @returns The current chainId
+   */ async chainId() {
+        const res = await this.rpcCall('eth_chainId', []);
+        return parseInt(res, 16);
+    }
+    /**
+   * Get the current timestamp
+   * @returns The current timestamp
+   */ async timestamp() {
+        const res = await this.rpcCall('eth_getBlockByNumber', [
+            'latest',
+            true
+        ]);
+        return parseInt(res.timestamp, 16);
+    }
+    /**
+   * Advance the chain by a number of blocks
+   * @param numberOfBlocks - The number of blocks to mine
+   */ async mine(numberOfBlocks = 1) {
+        await this.doMine(numberOfBlocks);
+        this.logger.warn(`Mined ${numberOfBlocks} L1 blocks`);
+    }
+    async doMine(numberOfBlocks = 1) {
+        try {
+            await this.rpcCall('hardhat_mine', [
+                numberOfBlocks
+            ]);
+        } catch (err) {
+            throw new Error(`Error mining: ${err}`);
+        }
+    }
+    /**
+   * Mines a single block with evm_mine
+   */ async evmMine() {
+        try {
+            await this.rpcCall('evm_mine', []);
+        } catch (err) {
+            throw new Error(`Error mining: ${err}`);
+        }
+    }
+    /**
+   * Set the balance of an account
+   * @param account - The account to set the balance for
+   * @param balance - The balance to set
+   */ async setBalance(account, balance) {
+        try {
+            await this.rpcCall('anvil_setBalance', [
+                account.toString(),
+                toHex(balance)
+            ]);
+        } catch (err) {
+            throw new Error(`Error setting balance for ${account}: ${err}`);
+        }
+        this.logger.warn(`Set balance for ${account} to ${balance}`);
+    }
+    /**
+   * Set the interval between blocks (block time)
+   * @param interval - The interval to use between blocks
+   */ async setBlockInterval(interval) {
+        try {
+            await this.rpcCall('anvil_setBlockTimestampInterval', [
+                interval
+            ]);
+        } catch (err) {
+            throw new Error(`Error setting block interval: ${err}`);
+        }
+        this.logger.warn(`Set L1 block interval to ${interval}`);
+    }
+    /**
+   * Set the next block base fee per gas
+   * @param baseFee - The base fee to set
+   */ async setNextBlockBaseFeePerGas(baseFee) {
+        try {
+            await this.rpcCall('anvil_setNextBlockBaseFeePerGas', [
+                baseFee.toString()
+            ]);
+        } catch (err) {
+            throw new Error(`Error setting next block base fee per gas: ${err}`);
+        }
+        this.logger.warn(`Set L1 next block base fee per gas to ${baseFee}`);
+    }
+    /**
+   * Set the interval between blocks (block time)
+   * @param seconds - The interval to use between blocks
+   */ async setIntervalMining(seconds) {
+        try {
+            await this.rpcCall('anvil_setIntervalMining', [
+                seconds
+            ]);
+        } catch (err) {
+            throw new Error(`Error setting interval mining: ${err}`);
+        }
+        this.logger.warn(`Set L1 interval mining to ${seconds} seconds`);
+    }
+    /**
+   * Set the automine status of the underlying anvil chain
+   * @param automine - The automine status to set
+   */ async setAutomine(automine) {
+        try {
+            await this.rpcCall('anvil_setAutomine', [
+                automine
+            ]);
+        } catch (err) {
+            throw new Error(`Error setting automine: ${err}`);
+        }
+        this.logger.warn(`Set L1 automine to ${automine}`);
+    }
+    /**
+   * Drop a transaction from the mempool
+   * @param txHash - The transaction hash
+   */ async dropTransaction(txHash) {
+        try {
+            await this.rpcCall('anvil_dropTransaction', [
+                txHash
+            ]);
+        } catch (err) {
+            throw new Error(`Error dropping transaction: ${err}`);
+        }
+        this.logger.warn(`Dropped transaction ${txHash}`);
+    }
+    /**
+   * Set the next block timestamp
+   * @param timestamp - The timestamp to set the next block to
+   */ async setNextBlockTimestamp(timestamp) {
+        try {
+            await this.rpcCall('evm_setNextBlockTimestamp', [
+                timestamp
+            ]);
+        } catch (err) {
+            throw new Error(`Error setting next block timestamp: ${err.message}`);
+        }
+        this.logger.warn(`Set L1 next block timestamp to ${timestamp}`);
+    }
+    /**
+   * Set the next block timestamp and mines the block
+   * @param timestamp - The timestamp to set the next block to
+   */ async warp(timestamp, silent = false) {
+        try {
+            await this.rpcCall('evm_setNextBlockTimestamp', [
+                Number(timestamp)
+            ]);
+        } catch (err) {
+            throw new Error(`Error warping: ${err}`);
+        }
+        await this.doMine();
+        if (!silent) {
+            this.logger.warn(`Warped L1 timestamp to ${timestamp}`);
+        }
+    }
+    /**
+   * Load the value at a storage slot of a contract address on eth
+   * @param contract - The contract address
+   * @param slot - The storage slot
+   * @returns - The value at the storage slot
+   */ async load(contract, slot) {
+        const res = await this.rpcCall('eth_getStorageAt', [
+            contract.toString(),
+            toHex(slot),
+            'latest'
+        ]);
+        return BigInt(res);
+    }
+    /**
+   * Set the value at a storage slot of a contract address on eth
+   * @param contract - The contract address
+   * @param slot - The storage slot
+   * @param value - The value to set the storage slot to
+   */ async store(contract, slot, value) {
+        // for the rpc call, we need to change value to be a 32 byte hex string.
+        try {
+            await this.rpcCall('hardhat_setStorageAt', [
+                contract.toString(),
+                toHex(slot),
+                toHex(value, true)
+            ]);
+        } catch (err) {
+            throw new Error(`Error setting storage for contract ${contract} at ${slot}: ${err}`);
+        }
+        this.logger.warn(`Set L1 storage for contract ${contract} at ${slot} to ${value}`);
+    }
+    /**
+   * Computes the slot value for a given map and key.
+   * @param baseSlot - The base slot of the map (specified in Aztec.nr contract)
+   * @param key - The key to lookup in the map
+   * @returns The storage slot of the value in the map
+   */ keccak256(baseSlot, key) {
+        // abi encode (removing the 0x) - concat key and baseSlot (both padded to 32 bytes)
+        const abiEncoded = toHex(key, true).substring(2) + toHex(baseSlot, true).substring(2);
+        return toBigIntBE(keccak256(Buffer.from(abiEncoded, 'hex')));
+    }
+    /**
+   * Send transactions impersonating an externally owned account or contract.
+   * @param who - The address to impersonate
+   */ async startImpersonating(who) {
+        try {
+            await this.rpcCall('hardhat_impersonateAccount', [
+                who.toString()
+            ]);
+        } catch (err) {
+            throw new Error(`Error impersonating ${who}: ${err}`);
+        }
+        this.logger.warn(`Impersonating ${who}`);
+    }
+    /**
+   * Stop impersonating an account that you are currently impersonating.
+   * @param who - The address to stop impersonating
+   */ async stopImpersonating(who) {
+        try {
+            await this.rpcCall('hardhat_stopImpersonatingAccount', [
+                who.toString()
+            ]);
+        } catch (err) {
+            throw new Error(`Error when stopping the impersonation of ${who}: ${err}`);
+        }
+        this.logger.warn(`Stopped impersonating ${who}`);
+    }
+    /**
+   * Set the bytecode for a contract
+   * @param contract - The contract address
+   * @param bytecode - The bytecode to set
+   */ async etch(contract, bytecode) {
+        try {
+            await this.rpcCall('hardhat_setCode', [
+                contract.toString(),
+                bytecode
+            ]);
+        } catch (err) {
+            throw new Error(`Error setting bytecode for ${contract}: ${err}`);
+        }
+        this.logger.warn(`Set bytecode for ${contract} to ${bytecode}`);
+    }
+    /**
+   * Get the bytecode for a contract
+   * @param contract - The contract address
+   * @returns The bytecode for the contract
+   */ async getBytecode(contract) {
+        const res = await this.rpcCall('eth_getCode', [
+            contract.toString(),
+            'latest'
+        ]);
+        return res;
+    }
+    /**
+   * Get the raw transaction object for a given transaction hash
+   * @param txHash - The transaction hash
+   * @returns The raw transaction
+   */ async getRawTransaction(txHash) {
+        const res = await this.rpcCall('debug_getRawTransaction', [
+            txHash
+        ]);
+        return res;
+    }
+}

package/dest/index.d.ts

@@ -0,0 +1,14 @@
+export * from './constants.js';
+export * from './deploy_l1_contracts.js';
+export * from './chain.js';
+export * from './eth_cheat_codes.js';
+export * from './l1_tx_utils.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';
+//# sourceMappingURL=index.d.ts.map

package/dest/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,0BAA0B,CAAC;AACzC,cAAc,YAAY,CAAC;AAC3B,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,sBAAsB,CAAC;AACrC,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC"}

package/dest/index.js

@@ -0,0 +1,13 @@
+export * from './constants.js';
+export * from './deploy_l1_contracts.js';
+export * from './chain.js';
+export * from './eth_cheat_codes.js';
+export * from './l1_tx_utils.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/dest/l1_contract_addresses.d.ts

@@ -0,0 +1,57 @@
+import type { ConfigMappingsType } from '@aztec/foundation/config';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { z } from 'zod';
+/**
+ * The names of the current L1 contract addresses.
+ * NOTE: When changing this list, make sure to update CLI & CI scripts accordingly.
+ * For reference: https://github.com/AztecProtocol/aztec-packages/pull/5553
+ */
+export declare const L1ContractsNames: readonly ["rollupAddress", "registryAddress", "inboxAddress", "outboxAddress", "feeJuiceAddress", "feeJuicePortalAddress", "coinIssuerAddress", "rewardDistributorAddress", "governanceProposerAddress", "governanceAddress", "stakingAssetAddress"];
+/** Provides the directory of current L1 contract addresses */
+export type L1ContractAddresses = {
+    [K in (typeof L1ContractsNames)[number]]: EthAddress;
+} & {
+    slashFactoryAddress?: EthAddress | undefined;
+};
+export declare const L1ContractAddressesSchema: z.ZodObject<{
+    rollupAddress: z.ZodType<EthAddress, any, string>;
+    registryAddress: z.ZodType<EthAddress, any, string>;
+    inboxAddress: z.ZodType<EthAddress, any, string>;
+    outboxAddress: z.ZodType<EthAddress, any, string>;
+    feeJuiceAddress: z.ZodType<EthAddress, any, string>;
+    stakingAssetAddress: z.ZodType<EthAddress, any, string>;
+    feeJuicePortalAddress: z.ZodType<EthAddress, any, string>;
+    coinIssuerAddress: z.ZodType<EthAddress, any, string>;
+    rewardDistributorAddress: z.ZodType<EthAddress, any, string>;
+    governanceProposerAddress: z.ZodType<EthAddress, any, string>;
+    governanceAddress: z.ZodType<EthAddress, any, string>;
+    slashFactoryAddress: z.ZodOptional<z.ZodType<EthAddress, any, string>>;
+}, "strip", z.ZodTypeAny, {
+    rollupAddress: EthAddress;
+    registryAddress: EthAddress;
+    inboxAddress: EthAddress;
+    outboxAddress: EthAddress;
+    feeJuiceAddress: EthAddress;
+    feeJuicePortalAddress: EthAddress;
+    coinIssuerAddress: EthAddress;
+    rewardDistributorAddress: EthAddress;
+    governanceProposerAddress: EthAddress;
+    governanceAddress: EthAddress;
+    stakingAssetAddress: EthAddress;
+    slashFactoryAddress?: EthAddress | undefined;
+}, {
+    rollupAddress: string;
+    registryAddress: string;
+    inboxAddress: string;
+    outboxAddress: string;
+    feeJuiceAddress: string;
+    feeJuicePortalAddress: string;
+    coinIssuerAddress: string;
+    rewardDistributorAddress: string;
+    governanceProposerAddress: string;
+    governanceAddress: string;
+    stakingAssetAddress: string;
+    slashFactoryAddress?: string | undefined;
+}>;
+export declare const l1ContractAddressesMapping: ConfigMappingsType<L1ContractAddresses>;
+//# sourceMappingURL=l1_contract_addresses.d.ts.map

package/dest/l1_contract_addresses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"l1_contract_addresses.d.ts","sourceRoot":"","sources":["../src/l1_contract_addresses.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAG3D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,sPAYnB,CAAC;AAEX,8DAA8D;AAC9D,MAAM,MAAM,mBAAmB,GAAG;KAC/B,CAAC,IAAI,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,GAAG,UAAU;CACrD,GAAG;IAAE,mBAAmB,CAAC,EAAE,UAAU,GAAG,SAAS,CAAA;CAAE,CAAC;AAErD,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAaE,CAAC;AAIzC,eAAO,MAAM,0BAA0B,EAAE,kBAAkB,CAAC,mBAAmB,CA6D9E,CAAC"}

package/dest/l1_contract_addresses.js

@@ -0,0 +1,97 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { schemas } from '@aztec/foundation/schemas';
+import { z } from 'zod';
+/**
+ * The names of the current L1 contract addresses.
+ * 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 = [
+    'rollupAddress',
+    'registryAddress',
+    'inboxAddress',
+    'outboxAddress',
+    'feeJuiceAddress',
+    'feeJuicePortalAddress',
+    'coinIssuerAddress',
+    'rewardDistributorAddress',
+    'governanceProposerAddress',
+    'governanceAddress',
+    'stakingAssetAddress'
+];
+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()
+});
+const parseEnv = (val)=>EthAddress.fromString(val);
+export const l1ContractAddressesMapping = {
+    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
+    }
+};

package/dest/l1_reader.d.ts

@@ -0,0 +1,16 @@
+import { type ConfigMappingsType } from '@aztec/foundation/config';
+import { type L1ContractAddresses } from './l1_contract_addresses.js';
+/** Configuration of the L1GlobalReader. */
+export interface L1ReaderConfig {
+    /** The RPC Url of the ethereum host. */
+    l1RpcUrls: 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;
+}
+export declare const l1ReaderConfigMappings: ConfigMappingsType<L1ReaderConfig>;
+export declare function getL1ReaderConfigFromEnv(): L1ReaderConfig;
+//# sourceMappingURL=l1_reader.d.ts.map

package/dest/l1_reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"l1_reader.d.ts","sourceRoot":"","sources":["../src/l1_reader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,kBAAkB,EAA6C,MAAM,0BAA0B,CAAC;AAE9G,OAAO,EAAE,KAAK,mBAAmB,EAA8B,MAAM,4BAA4B,CAAC;AAElG,2CAA2C;AAC3C,MAAM,WAAW,cAAc;IAC7B,wCAAwC;IACxC,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,yCAAyC;IACzC,SAAS,EAAE,MAAM,CAAC;IAClB,yCAAyC;IACzC,WAAW,EAAE,mBAAmB,CAAC;IACjC,2CAA2C;IAC3C,qBAAqB,EAAE,MAAM,CAAC;CAC/B;AAED,eAAO,MAAM,sBAAsB,EAAE,kBAAkB,CAAC,cAAc,CAqBrE,CAAC;AAEF,wBAAgB,wBAAwB,IAAI,cAAc,CAEzD"}