@aztec/ethereum 3.0.0-canary.a9708bd → 3.0.0-devnet.3

package/src/index.ts

@@ -1,7 +1,7 @@
 export * from './constants.js';
 export * from './deploy_l1_contracts.js';
 export * from './chain.js';
-export * from './l1_tx_utils.js';
+export * from './l1_tx_utils/index.js';
 export * from './l1_contract_addresses.js';
 export * from './l1_reader.js';
 export * from './utils.js';

package/src/l1_artifacts.ts

@@ -1,6 +1,8 @@
 import {
   CoinIssuerAbi,
   CoinIssuerBytecode,
+  DateGatedRelayerAbi,
+  DateGatedRelayerBytecode,
   EmpireSlasherDeploymentExtLibAbi,
   EmpireSlasherDeploymentExtLibBytecode,
   EmpireSlashingProposerAbi,
@@ -31,10 +33,10 @@ import {
   RegisterNewRollupVersionPayloadBytecode,
   RegistryAbi,
   RegistryBytecode,
-  RewardDeploymentExtLibAbi,
-  RewardDeploymentExtLibBytecode,
   RewardDistributorAbi,
   RewardDistributorBytecode,
+  RewardExtLibAbi,
+  RewardExtLibBytecode,
   RollupAbi,
   RollupBytecode,
   RollupLinkReferences,
@@ -100,10 +102,10 @@ export const RollupArtifact = {
         contractAbi: ValidatorOperationsExtLibAbi,
         contractBytecode: ValidatorOperationsExtLibBytecode as Hex,
       },
-      RewardDeploymentExtLib: {
-        name: 'RewardDeploymentExtLib',
-        contractAbi: RewardDeploymentExtLibAbi,
-        contractBytecode: RewardDeploymentExtLibBytecode as Hex,
+      RewardExtLib: {
+        name: 'RewardExtLib',
+        contractAbi: RewardExtLibAbi,
+        contractBytecode: RewardExtLibBytecode as Hex,
       },
       TallySlasherDeploymentExtLib: {
         name: 'TallySlasherDeploymentExtLib',
@@ -149,6 +151,12 @@ export const CoinIssuerArtifact = {
   contractBytecode: CoinIssuerBytecode as Hex,
 };
 
+export const DateGatedRelayerArtifact = {
+  name: 'DateGatedRelayer',
+  contractAbi: DateGatedRelayerAbi,
+  contractBytecode: DateGatedRelayerBytecode as Hex,
+};
+
 export const GovernanceProposerArtifact = {
   name: 'GovernanceProposer',
   contractAbi: GovernanceProposerAbi,

package/src/l1_contract_addresses.ts

@@ -32,6 +32,7 @@ export type L1ContractAddresses = {
   stakingAssetHandlerAddress?: EthAddress | undefined;
   zkPassportVerifierAddress?: EthAddress | undefined;
   gseAddress?: EthAddress | undefined;
+  dateGatedRelayerAddress?: EthAddress | undefined;
 };
 
 export const L1ContractAddressesSchema = z.object({
@@ -51,80 +52,70 @@ export const L1ContractAddressesSchema = z.object({
   stakingAssetHandlerAddress: schemas.EthAddress.optional(),
   zkPassportVerifierAddress: schemas.EthAddress.optional(),
   gseAddress: schemas.EthAddress.optional(),
+  dateGatedRelayerAddress: schemas.EthAddress.optional(),
 }) satisfies ZodFor<L1ContractAddresses>;
 
 const parseEnv = (val: string) => EthAddress.fromString(val);
 
 export const l1ContractAddressesMapping: ConfigMappingsType<
-  Omit<L1ContractAddresses, 'gseAddress' | 'zkPassportVerifierAddress'>
+  Omit<L1ContractAddresses, 'gseAddress' | 'zkPassportVerifierAddress' | 'dateGatedRelayerAddress'>
 > = {
-  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,
   },
+  slashFactoryAddress: {
+    env: 'SLASH_FACTORY_CONTRACT_ADDRESS',
+    description: 'The deployed L1 slashFactory contract address',
+    parseEnv,
+  },
+  feeAssetHandlerAddress: {
+    env: 'FEE_ASSET_HANDLER_CONTRACT_ADDRESS',
+    description: 'The deployed L1 feeAssetHandler contract address',
+    parseEnv,
+  },
+  rollupAddress: {
+    description: 'The deployed L1 rollup 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,
-  },
-  feeAssetHandlerAddress: {
-    env: 'FEE_ASSET_HANDLER_CONTRACT_ADDRESS',
-    description: 'The deployed L1 feeAssetHandler contract address',
-    parseEnv,
-  },
   stakingAssetHandlerAddress: {
-    env: 'STAKING_ASSET_HANDLER_CONTRACT_ADDRESS',
     description: 'The deployed L1 stakingAssetHandler contract address',
     parseEnv,
   },

package/src/l1_reader.ts

@@ -4,7 +4,7 @@ import { type L1ContractAddresses, l1ContractAddressesMapping } from './l1_contr
 
 /** Configuration of the L1GlobalReader. */
 export interface L1ReaderConfig {
-  /** 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;
@@ -15,20 +15,20 @@ export interface L1ReaderConfig {
 }
 
 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()),
+  l1Contracts: {
+    description: 'The deployed L1 contract addresses',
+    nested: l1ContractAddressesMapping,
   },
   l1ChainId: {
     env: 'L1_CHAIN_ID',
     parseEnv: (val: string) => +val,
-    defaultValue: 31337,
     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: [],
   },
   viemPollingIntervalMS: {
     env: 'L1_READER_VIEM_POLLING_INTERVAL_MS',

package/src/l1_tx_utils/README.md

@@ -0,0 +1,177 @@
+# L1 Transaction Utils
+
+This module handles sending L1 txs, including simulating txs, choosing gas prices, estimating gas limits, monitoring sent txs, speeding them up, and cancelling them. Each instance of `L1TxUtils` is stateful, corresponds to a given **publisher** EOA, and tracks its in-flight txs.
+
+## Usage context
+
+Aside from bootstrapping (such as deploying L1 contracts), the Aztec node sends txs to L1 for the following purposes:
+
+### Sequencing
+
+As a sequencer (ie block proposer), the node sends blob txs proposing new L2 blocks. These txs may be part of a multicall where the proposer also votes for a proposal, slashes other validators, or invalidates a block. If block building fails, the sequencer may send a multicall without a block (and hence without blobs). These actions have a specific set of L1 blocks in which they may land (ie an L2 slot, which lasts 2-6 L1 slots), after which they "expire" and revert if mined. On each L2 slot, at most one L1 tx is in-flight.
+
+A given block proposer is chosen at random. While chances are low, it could be the case that the same proposer is chosen for two L2 slots in a row.
+
+There is an edge case in which block building fails at the beginning of the slot (for instance, if there are not enough L2 txs to build the block), which means only a vote or a slash is sent to L1, but then the block does get built, and is submitted in a separate L1 tx.
+
+### Proving
+
+As a prover, the node sends a tx with a validity proof for an epoch. These txs also have an expiration window, after which they revert if they'd land. No blobs are used. The cost is 1M-4M gas, and these txs are sent at most once per epoch, which is about 96-384 L1 slots.
+
+Provers typically try proving all epochs. Today the proof submission window is set to one epoch, meaning that each epoch must be proven during the next, so there is no overlap. If this window were to be extended, then we could have multiple L1 proving txs in flight, which must land in order.
+
+## Properties
+
+From the usage context above, we know that:
+
+- Each publisher EOA has typically only one in-flight tx at a time.
+- Every tx has an expiration time after which they'd revert if mined.
+
+## State transitions
+
+We keep all our **publishers** split by scope, where the scope may be _proving_ or _sequencing_. If sequencing, publishers are also scoped by validator address, so a node that runs multiple validators may use different publisher accounts for each validator, to avoid publicly linking them. Note that a publisher may belong to more than one scope.
+
+Each publisher account is in one of the following states, which is reflected from the state of the tx with the highest nonce it has sent:
+
+- `idle`: Ready to send a tx
+- `sent`: A tx has been sent and we are awaiting for it to be mined
+- `speed-up`: The tx has been replaced with the same tx but higher gas price
+- `cancelled`: The tx has expired so it has been replaced with a noop tx
+- `not-mined`: The tx has expired or was dropped and we are no longer monitoring it
+- `mined`: The tx or one of its replacements (ie a tx with the same nonce) has been mined
+
+With the following state transitions:
+
+| From | To | Condition | Effect |
+|-|-|-|-|
+| `idle` | `sent` | `send_tx` | A new tx is sent and nonce is consumed |
+| `sent` | `speed-up`| `time_since_last_sent > stall_time && retry_attempts < max_retries` | The requested tx is replaced with an equivalent but higher gas price |
+| `sent`, `speed-up` | `not-mined` | `current_time > tx_timeout && !cancel_on_timeout` | The tx times out, nonce manager is reset |
+| `sent`, `speed-up` | `cancelled` | `current_time > tx_timeout && cancel_on_timeout` | The tx times out and we replace it with a noop |
+| `sent`, `speed-up`, `cancelled` | `mined` | `get_nonce(latest) > tx_nonce` | The tx or a replacement is mined |
+| `cancelled` | `not-mined` | `current_time > cancel_tx_timeout` | Cancellation times out, nonce manager is reset |
+| `cancelled` | `not-mined` | `nonce no longer in mempool && time_passed > unseen_considered_dropped` | Cancel tx dropped from mempool, nonce manager is reset |
+
+Note that we do not transition back to `idle`.
+
+## Nonce Management
+
+The `L1TxUtils` class uses a `NonceManager` from viem to track and manage nonces for the publisher account:
+
+- **Nonce consumption**: When sending a new transaction, the nonce is consumed from the nonce manager, which increments the internal counter.
+- **Nonce reset**: The nonce manager is reset in the following scenarios:
+  - When a regular tx times out without being cancelled (`NOT_MINED` state)
+  - When a cancellation tx is dropped from the mempool
+  - When a cancellation tx itself times out
+  - When we decide not to send a cancellation due to interruption or the original tx being dropped
+
+The reset allows the next transaction to reuse the nonce if the current tx is no longer in the mempool by the time this next transaction is sent.
+
+## Time checks
+
+All time checks for speed ups and time outs are based on L1 time, not local time. When se send a tx, we assign the `sent_at` time to the time of the most recent L1 block. Using L1 time means that speed ups and time outs can be expressed in terms of L1 slots. It also means that we will wait for a new L1 block to be mined and check if our tx is present in that block before computing time outs or speed ups. 
+
+An edge case here is that, if an L1 slot is missed (ie there is no L1 block for that slot), we won't update time outs during that 12s period. Given how infrequent these are, we are fine with this tradeoff.
+
+## Pseudocode
+
+```python
+def send_and_monitor_tx(tx_request):
+  # Always consume a fresh nonce from the nonce manager
+  nonce = nonce_manager.consume()
+
+  # Build and send the transaction
+  tx = make_tx(tx_request, nonce)
+  state = create_state(tx, status='sent')
+  txs.push(state)
+  l1.send_tx(tx)
+
+  # State transitions differ based on whether this is a cancel tx
+  is_cancel_tx = state.cancelTxHashes.length > 0
+
+  # Monitor loop
+  loop:
+    # Check if interrupted
+    if interrupted:
+      break
+
+    # Check if the tx was mined
+    current_nonce = l1.get_nonce(latest)
+    if current_nonce > nonce:
+      # Try to find the receipt from all tx attempts
+      for tx in state.txHashes + state.cancelTxHashes:
+        if receipt = l1.get_tx_receipt(tx):
+          state.status = 'mined'
+          return receipt
+      # Unknown tx was mined with our nonce
+      state.status = 'mined'
+      raise unknown_mined_tx_error
+
+    # Check if cancel tx dropped from mempool (only for cancellations)
+    pending_nonce = l1.get_nonce(pending)
+    if is_cancel_tx and pending_nonce < nonce and time_passed > unseen_considered_dropped:
+      state.status = 'idle'
+      nonce_manager.reset()
+      raise dropped_transaction_error
+
+    # Check if tx has timed out
+    if is_timed_out(state, l1_timestamp):
+      if is_cancel_tx or !cancel_on_timeout:
+        # Either already a cancel tx or configured not to cancel
+        state.status = 'not-mined'
+        nonce_manager.reset()
+        raise timeout_error
+      else:
+        # Send cancellation in background
+        run_in_background attempt_tx_cancellation(state)
+        raise timeout_error
+
+    # Speed up if stalled and have retries left
+    if time_since_last_sent > stall_time and attempts < max_attempts:
+      replacement_tx = make_tx(tx_request, nonce, bump_gas_price(state.gasPrice))
+      state.status = is_cancel_tx ? 'cancelled' : 'speed-up'
+      state.tx_hashes.push(send_tx(replacement_tx))
+      state.last_sent_at = now
+      continue
+
+    sleep(check_interval)
+
+def attempt_tx_cancellation(state):
+  # Check if original tx still in mempool
+  if l1.get_nonce(pending) < state.nonce:
+    state.status = 'not-mined'
+    nonce_manager.reset()
+    return
+
+  # Send noop tx with same nonce but higher gas
+  cancel_tx = make_noop_tx(state.nonce, bump_gas_price(state.gasPrice))
+  state.cancelTxHashes.push(send_tx(cancel_tx))
+  state.status = 'cancelled'
+
+  # Monitor the cancellation in background
+  run_in_background monitor_transaction(state)
+```
+
+## Publisher selection
+
+When sending a tx for a given scope, we choose from all publishers for the scope in the following order:
+
+- `idle`: The publisher is ready to be used and has not sent any txs recently.
+- `mined`: The publisher has mined a tx and is ready for a new one.
+- `speed-up`, `sent`: There is a tx in-flight, new one will be enqueued after (not eligible unless `publisherAllowInvalidStates` is set).
+- `cancelled`: There is a tx in-flight caused by a time-out mining the previous one, new tx will be enqueued after (not eligible unless `publisherAllowInvalidStates` is set).
+- `not-mined`: The previous tx timed out or was dropped, new tx will reuse the same nonce if previous one is no longer in the mempool, or pick the next otherwise (not eligible unless `publisherAllowInvalidStates` is enabled).
+
+If there is more than one publisher in the same state to choose from, we prefer choosing based on:
+1. Highest balance first
+2. Least recently used (based on `lastMinedAtBlockNumber`)
+
+Available publishers should be filtered by balance, ensuring that the given EOA has enough funds to send the tx, and possibly replace it with a larger gas price. If we detect a publisher account has not enough gas, we should warn (bonus points if we warn before running out).
+
+Note that selection is not handled by the `L1TxUtils` class but by the `PublisherManager`.
+
+## API
+
+- `sendTransaction`: Sends an L1 tx and returns the tx hash. Returns when the tx has been sent. Consumes a nonce from the nonce manager.
+- `monitorTransaction`: Monitors a sent tx and speeds up or cancels it. Returns when mined or timed out. May reset the nonce manager on timeout.
+- `sendAndMonitorTransaction`: Combines sending and monitoring in a single call.

package/src/l1_tx_utils/config.ts

@@ -0,0 +1,140 @@
+import {
+  type ConfigMappingsType,
+  bigintConfigHelper,
+  booleanConfigHelper,
+  getConfigFromMappings,
+  getDefaultConfig,
+  numberConfigHelper,
+} from '@aztec/foundation/config';
+
+export interface L1TxUtilsConfig {
+  /**
+   * How much to increase calculated gas limit.
+   */
+  gasLimitBufferPercentage?: number;
+  /**
+   * Maximum gas price in gwei
+   */
+  maxGwei?: bigint;
+  /**
+   * Maximum blob fee per gas in gwei
+   */
+  maxBlobGwei?: bigint;
+  /**
+   * Priority fee bump percentage
+   */
+  priorityFeeBumpPercentage?: number;
+  /**
+   * How much to increase priority fee by each attempt (percentage)
+   */
+  priorityFeeRetryBumpPercentage?: number;
+  /**
+   * Fixed priority fee per gas in Gwei. Overrides any priority fee bump percentage config
+   */
+  fixedPriorityFeePerGas?: number;
+  /**
+   * Maximum number of speed-up attempts
+   */
+  maxSpeedUpAttempts?: number;
+  /**
+   * How often to check tx status
+   */
+  checkIntervalMs?: number;
+  /**
+   * How long before considering tx stalled
+   */
+  stallTimeMs?: number;
+  /**
+   * How long to wait for a tx to be mined before giving up
+   */
+  txTimeoutMs?: number;
+  /**
+   * Whether to attempt to cancel a tx if it's not mined after txTimeoutMs
+   */
+  cancelTxOnTimeout?: boolean;
+  /**
+   * How long to wait for a cancellation tx to be mined after its last attempt before giving up
+   */
+  txCancellationFinalTimeoutMs?: number;
+  /**
+   * How long a tx nonce can be unseen in the mempool before considering it dropped
+   */
+  txUnseenConsideredDroppedMs?: number;
+}
+
+export const l1TxUtilsConfigMappings: ConfigMappingsType<L1TxUtilsConfig> = {
+  gasLimitBufferPercentage: {
+    description: 'How much to increase calculated gas limit by (percentage)',
+    env: 'L1_GAS_LIMIT_BUFFER_PERCENTAGE',
+    ...numberConfigHelper(20),
+  },
+  maxGwei: {
+    description: 'Maximum gas price in gwei',
+    env: 'L1_GAS_PRICE_MAX',
+    ...bigintConfigHelper(500n),
+  },
+  maxBlobGwei: {
+    description: 'Maximum blob fee per gas in gwei',
+    env: 'L1_BLOB_FEE_PER_GAS_MAX',
+    ...bigintConfigHelper(1_500n),
+  },
+  priorityFeeBumpPercentage: {
+    description: 'How much to increase priority fee by each attempt (percentage)',
+    env: 'L1_PRIORITY_FEE_BUMP_PERCENTAGE',
+    ...numberConfigHelper(20),
+  },
+  priorityFeeRetryBumpPercentage: {
+    description: 'How much to increase priority fee by each retry attempt (percentage)',
+    env: 'L1_PRIORITY_FEE_RETRY_BUMP_PERCENTAGE',
+    ...numberConfigHelper(50),
+  },
+  fixedPriorityFeePerGas: {
+    description: 'Fixed priority fee per gas in Gwei. Overrides any priority fee bump percentage',
+    env: 'L1_FIXED_PRIORITY_FEE_PER_GAS',
+    ...numberConfigHelper(0),
+  },
+  maxSpeedUpAttempts: {
+    description: 'Maximum number of speed-up attempts',
+    env: 'L1_TX_MONITOR_MAX_ATTEMPTS',
+    ...numberConfigHelper(3),
+  },
+  checkIntervalMs: {
+    description: 'How often to check tx status',
+    env: 'L1_TX_MONITOR_CHECK_INTERVAL_MS',
+    ...numberConfigHelper(1_000),
+  },
+  stallTimeMs: {
+    description: 'How long before considering tx stalled',
+    env: 'L1_TX_MONITOR_STALL_TIME_MS',
+    ...numberConfigHelper(24_000), // 24s, 2 ethereum slots
+  },
+  txTimeoutMs: {
+    description: 'How long to wait for a tx to be mined before giving up. Set to 0 to disable.',
+    env: 'L1_TX_MONITOR_TX_TIMEOUT_MS',
+    ...numberConfigHelper(120_000), // 2 mins
+  },
+  cancelTxOnTimeout: {
+    description: "Whether to attempt to cancel a tx if it's not mined after txTimeoutMs",
+    env: 'L1_TX_MONITOR_CANCEL_TX_ON_TIMEOUT',
+    ...booleanConfigHelper(true),
+  },
+  txCancellationFinalTimeoutMs: {
+    description: 'How long to wait for a cancellation tx after its last attempt before giving up',
+    env: 'L1_TX_MONITOR_TX_CANCELLATION_TIMEOUT_MS',
+    ...numberConfigHelper(24 * 12 * 1000), // 24 L1 blocks
+  },
+  txUnseenConsideredDroppedMs: {
+    description: 'How long a tx nonce can be unseen in the mempool before considering it dropped',
+    env: 'L1_TX_MONITOR_TX_UNSEEN_CONSIDERED_DROPPED_MS',
+    ...numberConfigHelper(6 * 12 * 1000), // 6 L1 blocks
+  },
+};
+
+// We abuse the fact that all mappings above have a non null default value and force-type this to Required
+export const defaultL1TxUtilsConfig = getDefaultConfig<L1TxUtilsConfig>(
+  l1TxUtilsConfigMappings,
+) as Required<L1TxUtilsConfig>;
+
+export function getL1TxUtilsConfigEnvVars(): L1TxUtilsConfig {
+  return getConfigFromMappings(l1TxUtilsConfigMappings);
+}

package/src/l1_tx_utils/constants.ts

@@ -0,0 +1,18 @@
+// 1_000_000_000 Gwei = 1 ETH
+// 1_000_000_000 Wei = 1 Gwei
+// 1_000_000_000_000_000_000 Wei = 1 ETH
+export const WEI_CONST = 1_000_000_000n;
+
+// @note using this large gas limit to avoid the issue of `gas limit too low` when estimating gas in reth
+export const LARGE_GAS_LIMIT = 12_000_000n;
+
+// setting a minimum bump percentage to 10% due to geth's implementation
+// https://github.com/ethereum/go-ethereum/blob/e3d61e6db028c412f74bc4d4c7e117a9e29d0de0/core/txpool/legacypool/list.go#L298
+export const MIN_REPLACEMENT_BUMP_PERCENTAGE = 10;
+
+// setting a minimum bump percentage to 100% due to geth's implementation
+// https://github.com/ethereum/go-ethereum/blob/e3d61e6db028c412f74bc4d4c7e117a9e29d0de0/core/txpool/blobpool/config.go#L34
+export const MIN_BLOB_REPLACEMENT_BUMP_PERCENTAGE = 100;
+
+// Avg ethereum block time is ~12s
+export const BLOCK_TIME_MS = 12_000;

package/src/l1_tx_utils/factory.ts

@@ -0,0 +1,64 @@
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { Logger } from '@aztec/foundation/log';
+import { DateProvider } from '@aztec/foundation/timer';
+
+import type { TransactionSerializable } from 'viem';
+
+import type { EthSigner } from '../eth-signer/eth-signer.js';
+import type { ExtendedViemWalletClient, ViemClient } from '../types.js';
+import type { L1TxUtilsConfig } from './config.js';
+import type { IL1TxMetrics, IL1TxStore } from './interfaces.js';
+import { L1TxUtils } from './l1_tx_utils.js';
+import { createViemSigner } from './signer.js';
+import type { SigningCallback } from './types.js';
+
+export function createL1TxUtilsFromViemWallet(
+  client: ExtendedViemWalletClient,
+  deps?: {
+    logger?: Logger;
+    dateProvider?: DateProvider;
+    store?: IL1TxStore;
+    metrics?: IL1TxMetrics;
+  },
+  config?: Partial<L1TxUtilsConfig> & { debugMaxGasLimit?: boolean },
+): L1TxUtils {
+  return new L1TxUtils(
+    client,
+    EthAddress.fromString(client.account.address),
+    createViemSigner(client),
+    deps?.logger,
+    deps?.dateProvider,
+    config,
+    config?.debugMaxGasLimit ?? false,
+    deps?.store,
+    deps?.metrics,
+  );
+}
+
+export function createL1TxUtilsFromEthSigner(
+  client: ViemClient,
+  signer: EthSigner,
+  deps?: {
+    logger?: Logger;
+    dateProvider?: DateProvider;
+    store?: IL1TxStore;
+    metrics?: IL1TxMetrics;
+  },
+  config?: Partial<L1TxUtilsConfig> & { debugMaxGasLimit?: boolean },
+): L1TxUtils {
+  const callback: SigningCallback = async (transaction: TransactionSerializable, _signingAddress) => {
+    return (await signer.signTransaction(transaction)).toViemTransactionSignature();
+  };
+
+  return new L1TxUtils(
+    client,
+    signer.address,
+    callback,
+    deps?.logger,
+    deps?.dateProvider,
+    config,
+    config?.debugMaxGasLimit ?? false,
+    deps?.store,
+    deps?.metrics,
+  );
+}

package/src/l1_tx_utils/index.ts

@@ -0,0 +1,12 @@
+export * from './config.js';
+export * from './constants.js';
+export * from './factory.js';
+export * from './interfaces.js';
+export * from './l1_tx_utils.js';
+export * from './readonly_l1_tx_utils.js';
+export * from './signer.js';
+export * from './types.js';
+export * from './utils.js';
+
+// Note: We intentionally do not export l1_tx_utils_with_blobs.js
+// to avoid accidentally importing blob-lib dependency.