Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit da29daa

Browse files
prestwichprestwich
committedMay 8, 2025··
refactor: update config to use derive
1 parent 7a12d58 commit da29daa

File tree

6 files changed

+156
-238
lines changed

6 files changed

+156
-238
lines changed
 

‎bin/builder.rs

+6-9
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,7 @@ use builder::{
66
tx_poller,
77
},
88
};
9-
use init4_bin_base::{deps::tracing, utils::calc::SlotCalculator};
9+
use init4_bin_base::{deps::tracing, utils::from_env::FromEnv};
1010
use signet_sim::SimCache;
1111
use std::sync::Arc;
1212
use tokio::select;
@@ -19,15 +19,13 @@ async fn main() -> eyre::Result<()> {
1919
let _guard = init4_bin_base::init4();
2020
let init_span_guard = info_span!("builder initialization");
2121

22-
let config = BuilderConfig::load_from_env()?.clone();
22+
let config = BuilderConfig::from_env()?.clone();
2323
let constants = config.load_pecorino_constants();
2424
let authenticator = Authenticator::new(&config)?;
2525

26-
let (host_provider, ru_provider, sequencer_signer) = tokio::try_join!(
27-
config.connect_host_provider(),
28-
config.connect_ru_provider(),
29-
config.connect_sequencer_signer(),
30-
)?;
26+
let (host_provider, sequencer_signer) =
27+
tokio::try_join!(config.connect_host_provider(), config.connect_sequencer_signer(),)?;
28+
let ru_provider = config.connect_ru_provider();
3129

3230
let zenith = config.connect_zenith(host_provider.clone());
3331

@@ -55,8 +53,7 @@ async fn main() -> eyre::Result<()> {
5553
let (submit_channel, submit_jh) = submit.spawn();
5654

5755
let sim_items = SimCache::new();
58-
let slot_calculator =
59-
SlotCalculator::new(config.start_timestamp, config.chain_offset, config.target_slot_time);
56+
let slot_calculator = config.slot_calculator;
6057

6158
let sim = Arc::new(Simulator::new(&config, ru_provider.clone(), slot_calculator));
6259

‎bin/submit_transaction.rs

+38-28
Original file line numberDiff line numberDiff line change
@@ -5,32 +5,65 @@ use alloy::{
55
rpc::types::eth::TransactionRequest,
66
signers::aws::AwsSigner,
77
};
8-
use aws_config::BehaviorVersion;
9-
use builder::config::{HostProvider, load_address, load_string, load_u64, load_url};
8+
use builder::config::HostProvider;
109
use init4_bin_base::{
1110
deps::metrics::{counter, histogram},
1211
init4,
12+
utils::from_env::FromEnv,
1313
};
1414
use std::time::{Duration, Instant};
1515
use tokio::time::timeout;
1616

17+
#[derive(Debug, Clone, FromEnv)]
18+
struct Config {
19+
#[from_env(var = "RPC_URL", desc = "Ethereum RPC URL")]
20+
rpc_url: String,
21+
#[from_env(var = "CHAIN_ID", desc = "Ethereum chain ID")]
22+
chain_id: u64,
23+
#[from_env(var = "AWS_KMS_KEY_ID", desc = "AWS KMS key ID")]
24+
kms_key_id: String,
25+
#[from_env(var = "RECIPIENT_ADDRESS", desc = "Recipient address")]
26+
recipient_address: Address,
27+
#[from_env(var = "SLEEP_TIME", desc = "Time to sleep between transactions")]
28+
sleep_time: u64,
29+
}
30+
31+
impl Config {
32+
async fn provider(&self) -> HostProvider {
33+
let config = aws_config::load_defaults(aws_config::BehaviorVersion::latest()).await;
34+
let client = aws_sdk_kms::Client::new(&config);
35+
let signer =
36+
AwsSigner::new(client, self.kms_key_id.clone(), Some(self.chain_id)).await.unwrap();
37+
38+
ProviderBuilder::new()
39+
.wallet(EthereumWallet::from(signer))
40+
.connect(&self.rpc_url)
41+
.await
42+
.unwrap()
43+
}
44+
}
45+
1746
#[tokio::main]
1847
async fn main() {
1948
init4();
2049

2150
tracing::trace!("connecting to provider");
22-
let (provider, recipient_address, sleep_time) = connect_from_config().await;
51+
52+
let config = Config::from_env().unwrap();
53+
let provider = config.provider().await;
54+
let recipient_address = config.recipient_address;
55+
let sleep_time = config.sleep_time;
2356

2457
loop {
2558
tracing::debug!("attempting transaction");
26-
send_transaction(provider.clone(), recipient_address).await;
59+
send_transaction(&provider, recipient_address).await;
2760

2861
tracing::debug!(sleep_time, "sleeping");
2962
tokio::time::sleep(tokio::time::Duration::from_secs(sleep_time)).await;
3063
}
3164
}
3265

33-
async fn send_transaction(provider: HostProvider, recipient_address: Address) {
66+
async fn send_transaction(provider: &HostProvider, recipient_address: Address) {
3467
// construct simple transaction to send ETH to a recipient
3568
let tx = TransactionRequest::default()
3669
.with_from(provider.default_signer_address())
@@ -66,26 +99,3 @@ async fn send_transaction(provider: HostProvider, recipient_address: Address) {
6699
tracing::debug!(success = receipt.status(), mine_time, hash, "transaction mined");
67100
histogram!("txn_submitter.tx_mine_time").record(mine_time as f64);
68101
}
69-
70-
async fn connect_from_config() -> (HostProvider, Address, u64) {
71-
// load signer config values from .env
72-
let rpc_url = load_url("RPC_URL").unwrap();
73-
let chain_id = load_u64("CHAIN_ID").unwrap();
74-
let kms_key_id = load_string("AWS_KMS_KEY_ID").unwrap();
75-
// load transaction sending config value from .env
76-
let recipient_address: Address = load_address("RECIPIENT_ADDRESS").unwrap();
77-
let sleep_time = load_u64("SLEEP_TIME").unwrap();
78-
79-
// connect signer & provider
80-
let config = aws_config::load_defaults(BehaviorVersion::latest()).await;
81-
let client = aws_sdk_kms::Client::new(&config);
82-
let signer = AwsSigner::new(client, kms_key_id.to_string(), Some(chain_id)).await.unwrap();
83-
84-
let provider = ProviderBuilder::new()
85-
.wallet(EthereumWallet::from(signer))
86-
.connect(&rpc_url)
87-
.await
88-
.unwrap();
89-
90-
(provider, recipient_address, sleep_time)
91-
}

‎src/config.rs

+104-190
Original file line numberDiff line numberDiff line change
@@ -14,235 +14,196 @@ use alloy::{
1414
},
1515
};
1616
use eyre::Result;
17+
use init4_bin_base::utils::{calc::SlotCalculator, from_env::FromEnv};
1718
use oauth2::url;
1819
use signet_types::config::{HostConfig, PredeployTokens, RollupConfig, SignetSystemConstants};
1920
use signet_zenith::Zenith;
20-
use std::{borrow::Cow, env, num, str::FromStr};
21+
use std::borrow::Cow;
2122

22-
// Keys for .env variables that need to be set to configure the builder.
23-
const HOST_CHAIN_ID: &str = "HOST_CHAIN_ID";
24-
const RU_CHAIN_ID: &str = "RU_CHAIN_ID";
25-
const HOST_RPC_URL: &str = "HOST_RPC_URL";
26-
const ROLLUP_RPC_URL: &str = "ROLLUP_RPC_URL";
27-
const TX_BROADCAST_URLS: &str = "TX_BROADCAST_URLS";
28-
const ZENITH_ADDRESS: &str = "ZENITH_ADDRESS";
29-
const BUILDER_HELPER_ADDRESS: &str = "BUILDER_HELPER_ADDRESS";
30-
const QUINCEY_URL: &str = "QUINCEY_URL";
31-
const BUILDER_PORT: &str = "BUILDER_PORT";
32-
const SEQUENCER_KEY: &str = "SEQUENCER_KEY"; // empty (to use Quincey) OR AWS key ID (to use AWS signer) OR raw private key (to use local signer)
33-
const BUILDER_KEY: &str = "BUILDER_KEY"; // AWS key ID (to use AWS signer) OR raw private key (to use local signer)
34-
const BLOCK_CONFIRMATION_BUFFER: &str = "BLOCK_CONFIRMATION_BUFFER";
35-
const CHAIN_OFFSET: &str = "CHAIN_OFFSET";
36-
const TARGET_SLOT_TIME: &str = "TARGET_SLOT_TIME";
37-
const BUILDER_REWARDS_ADDRESS: &str = "BUILDER_REWARDS_ADDRESS";
38-
const ROLLUP_BLOCK_GAS_LIMIT: &str = "ROLLUP_BLOCK_GAS_LIMIT";
39-
const TX_POOL_URL: &str = "TX_POOL_URL";
40-
const AUTH_TOKEN_REFRESH_INTERVAL: &str = "AUTH_TOKEN_REFRESH_INTERVAL";
41-
const TX_POOL_CACHE_DURATION: &str = "TX_POOL_CACHE_DURATION";
42-
const OAUTH_CLIENT_ID: &str = "OAUTH_CLIENT_ID";
43-
const OAUTH_CLIENT_SECRET: &str = "OAUTH_CLIENT_SECRET";
44-
const OAUTH_AUTHENTICATE_URL: &str = "OAUTH_AUTHENTICATE_URL";
45-
const OAUTH_TOKEN_URL: &str = "OAUTH_TOKEN_URL";
46-
const CONCURRENCY_LIMIT: &str = "CONCURRENCY_LIMIT";
47-
const START_TIMESTAMP: &str = "START_TIMESTAMP";
23+
/// Type alias for the provider used to build and submit blocks to the host.
24+
pub type HostProvider = FillProvider<
25+
JoinFill<
26+
JoinFill<
27+
Identity,
28+
JoinFill<GasFiller, JoinFill<BlobGasFiller, JoinFill<NonceFiller, ChainIdFiller>>>,
29+
>,
30+
WalletFiller<EthereumWallet>,
31+
>,
32+
RootProvider,
33+
Ethereum,
34+
>;
4835

4936
/// Configuration for a builder running a specific rollup on a specific host
5037
/// chain.
51-
#[derive(serde::Serialize, serde::Deserialize, Debug, Clone)]
38+
#[derive(serde::Deserialize, Debug, Clone, FromEnv)]
5239
pub struct BuilderConfig {
5340
/// The chain ID of the host chain
41+
#[from_env(var = "HOST_CHAIN_ID", desc = "The chain ID of the host chain")]
5442
pub host_chain_id: u64,
55-
/// The chain ID of the host chain
43+
/// The chain ID of the rollup chain
44+
#[from_env(var = "RU_CHAIN_ID", desc = "The chain ID of the rollup chain")]
5645
pub ru_chain_id: u64,
5746
/// URL for Host RPC node.
47+
#[from_env(var = "HOST_RPC_URL", desc = "URL for Host RPC node", infallible)]
5848
pub host_rpc_url: Cow<'static, str>,
5949
/// URL for the Rollup RPC node.
50+
#[from_env(var = "ROLLUP_RPC_URL", desc = "URL for Rollup RPC node", infallible)]
6051
pub ru_rpc_url: Cow<'static, str>,
6152
/// Additional RPC URLs to which to broadcast transactions.
6253
/// NOTE: should not include the host_rpc_url value
54+
#[from_env(
55+
var = "TX_BROADCAST_URLS",
56+
desc = "Additional RPC URLs to which to broadcast transactions",
57+
infallible
58+
)]
6359
pub tx_broadcast_urls: Vec<Cow<'static, str>>,
6460
/// address of the Zenith contract on Host.
61+
#[from_env(var = "ZENITH_ADDRESS", desc = "address of the Zenith contract on Host")]
6562
pub zenith_address: Address,
6663
/// address of the Builder Helper contract on Host.
64+
#[from_env(
65+
var = "BUILDER_HELPER_ADDRESS",
66+
desc = "address of the Builder Helper contract on Host"
67+
)]
6768
pub builder_helper_address: Address,
6869
/// URL for remote Quincey Sequencer server to sign blocks.
6970
/// Disregarded if a sequencer_signer is configured.
71+
#[from_env(
72+
var = "QUINCEY_URL",
73+
desc = "URL for remote Quincey Sequencer server to sign blocks",
74+
infallible
75+
)]
7076
pub quincey_url: Cow<'static, str>,
7177
/// Port for the Builder server.
78+
#[from_env(var = "BUILDER_PORT", desc = "Port for the Builder server")]
7279
pub builder_port: u16,
7380
/// Key to access Sequencer Wallet - AWS Key ID _OR_ local private key.
7481
/// Set IFF using local Sequencer signing instead of remote Quincey signing.
82+
#[from_env(
83+
var = "SEQUENCER_KEY",
84+
desc = "Key to access Sequencer Wallet - AWS Key ID _OR_ local private key, set IFF using local Sequencer signing instead of remote Quincey signing",
85+
infallible,
86+
optional
87+
)]
7588
pub sequencer_key: Option<String>,
7689
/// Key to access Builder transaction submission wallet - AWS Key ID _OR_ local private key.
90+
#[from_env(
91+
var = "BUILDER_KEY",
92+
desc = "Key to access Builder transaction submission wallet - AWS Key ID _OR_ local private key",
93+
infallible
94+
)]
7795
pub builder_key: String,
7896
/// Buffer in seconds in which the `submitBlock` transaction must confirm on the Host chain.
97+
#[from_env(
98+
var = "BLOCK_CONFIRMATION_BUFFER",
99+
desc = "Buffer in seconds in which the `submitBlock` transaction must confirm on the Host chain"
100+
)]
79101
pub block_confirmation_buffer: u64,
80-
/// The offset between Unix time and the chain's block times. For Holesky, this is 0; for Ethereum, 11.
81-
pub chain_offset: u64,
82-
/// The slot time at which the Builder should begin building a block. 0 to begin at the very start of the slot; 6 to begin in the middle; etc.
83-
pub target_slot_time: u64,
102+
84103
/// Address on Rollup to which Builder will receive user transaction fees.
104+
#[from_env(
105+
var = "BUILDER_REWARDS_ADDRESS",
106+
desc = "Address on Rollup to which Builder will receive user transaction fees"
107+
)]
85108
pub builder_rewards_address: Address,
86109
/// Gas limit for RU block.
87110
/// NOTE: a "smart" builder would determine this programmatically by simulating the block.
111+
#[from_env(var = "ROLLUP_BLOCK_GAS_LIMIT", desc = "Gas limit for RU block")]
88112
pub rollup_block_gas_limit: u64,
89113
/// URL of the tx pool to poll for incoming transactions.
114+
#[from_env(
115+
var = "TX_POOL_URL",
116+
desc = "URL of the tx pool to poll for incoming transactions",
117+
infallible
118+
)]
90119
pub tx_pool_url: Cow<'static, str>,
91120
/// Duration in seconds transactions can live in the tx-pool cache.
121+
#[from_env(
122+
var = "AUTH_TOKEN_REFRESH_INTERVAL",
123+
desc = "Duration in seconds transactions can live in the tx-pool cache"
124+
)]
92125
pub tx_pool_cache_duration: u64,
93126
/// OAuth client ID for the builder.
127+
#[from_env(var = "TX_POOL_CACHE_DURATION", desc = "OAuth client ID for the builder")]
94128
pub oauth_client_id: String,
95129
/// OAuth client secret for the builder.
130+
#[from_env(var = "OAUTH_CLIENT_ID", desc = "OAuth client secret for the builder")]
96131
pub oauth_client_secret: String,
97132
/// OAuth authenticate URL for the builder for performing OAuth logins.
133+
#[from_env(
134+
var = "OAUTH_CLIENT_SECRET",
135+
desc = "OAuth authenticate URL for the builder for performing OAuth logins"
136+
)]
98137
pub oauth_authenticate_url: String,
99138
/// OAuth token URL for the builder to get an OAuth2 access token
139+
#[from_env(
140+
var = "OAUTH_AUTHENTICATE_URL",
141+
desc = "OAuth token URL for the builder to get an OAuth2 access token"
142+
)]
100143
pub oauth_token_url: String,
101144
/// The oauth token refresh interval in seconds.
145+
#[from_env(var = "OAUTH_TOKEN_URL", desc = "The oauth token refresh interval in seconds")]
102146
pub oauth_token_refresh_interval: u64,
103147
/// The max number of simultaneous block simulations to run.
148+
#[from_env(
149+
var = "CONCURRENCY_LIMIT",
150+
desc = "The max number of simultaneous block simulations to run"
151+
)]
104152
pub concurrency_limit: usize,
105-
/// The anchor for slot time and number calculations before adjusting for chain offset.
106-
pub start_timestamp: u64,
107-
}
108-
109-
/// Error loading the configuration.
110-
#[derive(Debug, thiserror::Error)]
111-
pub enum ConfigError {
112-
/// Error loading from environment variable
113-
#[error("missing or non-unicode environment variable: {0}")]
114-
Var(String),
115-
/// Error parsing environment variable
116-
#[error("failed to parse environment variable: {0}")]
117-
Parse(#[from] num::ParseIntError),
118-
/// Error parsing boolean environment variable
119-
#[error("failed to parse boolean environment variable")]
120-
ParseBool,
121-
/// Error parsing hex from environment variable
122-
#[error("failed to parse hex: {0}")]
123-
Hex(#[from] hex::FromHexError),
124-
/// Error connecting to the provider
125-
#[error("failed to connect to provider: {0}")]
126-
Provider(#[from] alloy::transports::TransportError),
127-
/// Error connecting to the signer
128-
#[error("failed to connect to signer: {0}")]
129-
Signer(#[from] SignerError),
130-
/// I/O error
131-
#[error("I/O error: {0}")]
132-
Io(#[from] std::io::Error),
133-
}
134153

135-
impl ConfigError {
136-
/// Missing or non-unicode env var.
137-
pub fn missing(s: &str) -> Self {
138-
ConfigError::Var(s.to_string())
139-
}
154+
/// The slot calculator for the builder.
155+
pub slot_calculator: SlotCalculator,
140156
}
141157

142-
/// Type alias for the provider used to build and submit blocks to the host.
143-
pub type HostProvider = FillProvider<
144-
JoinFill<
145-
JoinFill<
146-
Identity,
147-
JoinFill<GasFiller, JoinFill<BlobGasFiller, JoinFill<NonceFiller, ChainIdFiller>>>,
148-
>,
149-
WalletFiller<EthereumWallet>,
150-
>,
151-
RootProvider,
152-
Ethereum,
153-
>;
154-
155158
/// Type alias for the provider used to simulate against rollup state.
156159
pub type RuProvider = RootProvider<Ethereum>;
157160

158161
/// A [`Zenith`] contract instance using [`Provider`] as the provider.
159162
pub type ZenithInstance<P = HostProvider> = Zenith::ZenithInstance<(), P, alloy::network::Ethereum>;
160163

161164
impl BuilderConfig {
162-
/// Load the builder configuration from environment variables.
163-
pub fn load_from_env() -> Result<BuilderConfig, ConfigError> {
164-
Ok(BuilderConfig {
165-
host_chain_id: load_u64(HOST_CHAIN_ID)?,
166-
ru_chain_id: load_u64(RU_CHAIN_ID)?,
167-
host_rpc_url: load_url(HOST_RPC_URL)?,
168-
ru_rpc_url: load_url(ROLLUP_RPC_URL)?,
169-
tx_broadcast_urls: env::var(TX_BROADCAST_URLS)
170-
.unwrap_or_default()
171-
.split(',')
172-
.map(str::trim)
173-
.filter(|url| !url.is_empty())
174-
.map(ToOwned::to_owned)
175-
.map(Into::into)
176-
.collect(),
177-
zenith_address: load_address(ZENITH_ADDRESS)?,
178-
builder_helper_address: load_address(BUILDER_HELPER_ADDRESS)?,
179-
quincey_url: load_url(QUINCEY_URL)?,
180-
builder_port: load_u16(BUILDER_PORT)?,
181-
sequencer_key: load_string_option(SEQUENCER_KEY),
182-
builder_key: load_string(BUILDER_KEY)?,
183-
block_confirmation_buffer: load_u64(BLOCK_CONFIRMATION_BUFFER)?,
184-
chain_offset: load_u64(CHAIN_OFFSET)?,
185-
target_slot_time: load_u64(TARGET_SLOT_TIME)?,
186-
builder_rewards_address: load_address(BUILDER_REWARDS_ADDRESS)?,
187-
rollup_block_gas_limit: load_u64(ROLLUP_BLOCK_GAS_LIMIT)?,
188-
tx_pool_url: load_url(TX_POOL_URL)?,
189-
tx_pool_cache_duration: load_u64(TX_POOL_CACHE_DURATION)?,
190-
oauth_client_id: load_string(OAUTH_CLIENT_ID)?,
191-
oauth_client_secret: load_string(OAUTH_CLIENT_SECRET)?,
192-
oauth_authenticate_url: load_string(OAUTH_AUTHENTICATE_URL)?,
193-
oauth_token_url: load_string(OAUTH_TOKEN_URL)?,
194-
oauth_token_refresh_interval: load_u64(AUTH_TOKEN_REFRESH_INTERVAL)?,
195-
concurrency_limit: load_concurrency_limit()?,
196-
start_timestamp: load_u64(START_TIMESTAMP)?,
197-
})
198-
}
199-
200165
/// Connect to the Builder signer.
201-
pub async fn connect_builder_signer(&self) -> Result<LocalOrAws, ConfigError> {
202-
LocalOrAws::load(&self.builder_key, Some(self.host_chain_id)).await.map_err(Into::into)
166+
pub async fn connect_builder_signer(&self) -> Result<LocalOrAws, SignerError> {
167+
LocalOrAws::load(&self.builder_key, Some(self.host_chain_id)).await
203168
}
204169

205170
/// Connect to the Sequencer signer.
206-
pub async fn connect_sequencer_signer(&self) -> Result<Option<LocalOrAws>, ConfigError> {
207-
match &self.sequencer_key {
208-
Some(sequencer_key) => LocalOrAws::load(sequencer_key, Some(self.host_chain_id))
171+
pub async fn connect_sequencer_signer(&self) -> eyre::Result<Option<LocalOrAws>> {
172+
if let Some(sequencer_key) = &self.sequencer_key {
173+
LocalOrAws::load(sequencer_key, Some(self.host_chain_id))
209174
.await
210175
.map_err(Into::into)
211-
.map(Some),
212-
None => Ok(None),
176+
.map(Some)
177+
} else {
178+
Ok(None)
213179
}
214180
}
215181

216182
/// Connect to the Rollup rpc provider.
217-
pub async fn connect_ru_provider(&self) -> Result<RootProvider<Ethereum>, ConfigError> {
183+
pub fn connect_ru_provider(&self) -> RootProvider<Ethereum> {
218184
let url = url::Url::parse(&self.ru_rpc_url).expect("failed to parse URL");
219-
let provider = RootProvider::<Ethereum>::new_http(url);
220-
Ok(provider)
185+
RootProvider::<Ethereum>::new_http(url)
221186
}
222187

223188
/// Connect to the Host rpc provider.
224-
pub async fn connect_host_provider(&self) -> Result<HostProvider, ConfigError> {
189+
pub async fn connect_host_provider(&self) -> eyre::Result<HostProvider> {
225190
let builder_signer = self.connect_builder_signer().await?;
226-
let provider = ProviderBuilder::new()
191+
ProviderBuilder::new()
227192
.wallet(EthereumWallet::from(builder_signer))
228193
.connect(&self.host_rpc_url)
229194
.await
230-
.map_err(ConfigError::Provider)?;
231-
232-
Ok(provider)
195+
.map_err(Into::into)
233196
}
234197

235198
/// Connect additional broadcast providers.
236-
pub async fn connect_additional_broadcast(&self) -> Result<Vec<RootProvider>, ConfigError> {
237-
let mut providers: Vec<RootProvider> = Vec::with_capacity(self.tx_broadcast_urls.len());
238-
239-
for url_str in self.tx_broadcast_urls.iter() {
240-
let url = url::Url::parse(url_str).expect("failed to parse URL");
241-
let provider = RootProvider::new_http(url);
242-
providers.push(provider);
243-
}
244-
245-
Ok(providers)
199+
pub fn connect_additional_broadcast(&self) -> Vec<RootProvider> {
200+
self.tx_broadcast_urls
201+
.iter()
202+
.map(|url_str| {
203+
let url = url::Url::parse(url_str).expect("failed to parse URL");
204+
RootProvider::new_http(url)
205+
})
206+
.collect::<Vec<_>>()
246207
}
247208

248209
/// Connect to the Zenith instance, using the specified provider.
@@ -276,50 +237,3 @@ impl BuilderConfig {
276237
SignetSystemConstants::new(host, rollup)
277238
}
278239
}
279-
280-
/// Load a string from an environment variable.
281-
pub fn load_string(key: &str) -> Result<String, ConfigError> {
282-
env::var(key).map_err(|_| ConfigError::missing(key))
283-
}
284-
285-
/// Load a string from an environment variable, returning None if the variable
286-
/// is not set.
287-
fn load_string_option(key: &str) -> Option<String> {
288-
load_string(key).ok()
289-
}
290-
291-
/// Load a boolean from an environment variable.
292-
pub fn load_u64(key: &str) -> Result<u64, ConfigError> {
293-
let val = load_string(key)?;
294-
val.parse::<u64>().map_err(Into::into)
295-
}
296-
297-
/// Load a u16 from an environment variable.
298-
fn load_u16(key: &str) -> Result<u16, ConfigError> {
299-
let val = load_string(key)?;
300-
val.parse::<u16>().map_err(Into::into)
301-
}
302-
303-
/// Load a URL from an environment variable.
304-
pub fn load_url(key: &str) -> Result<Cow<'static, str>, ConfigError> {
305-
load_string(key).map(Into::into)
306-
}
307-
308-
/// Load an address from an environment variable.
309-
pub fn load_address(key: &str) -> Result<Address, ConfigError> {
310-
let address = load_string(key)?;
311-
Address::from_str(&address)
312-
.map_err(|_| ConfigError::Var(format!("Invalid address format for {}", key)))
313-
}
314-
315-
/// Checks the configured concurrency parameter and, if none is set, checks the available
316-
/// system concurrency with `std::thread::available_parallelism` and returns that.
317-
pub fn load_concurrency_limit() -> Result<usize, ConfigError> {
318-
match load_u16(CONCURRENCY_LIMIT) {
319-
Ok(env) => Ok(env as usize),
320-
Err(_) => {
321-
let limit = std::thread::available_parallelism()?.get();
322-
Ok(limit)
323-
}
324-
}
325-
}

‎src/tasks/submit.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -206,7 +206,7 @@ impl SubmitTask {
206206
let fut = spawn_provider_send!(&self.host_provider, &tx);
207207

208208
// Spawn send_tx futures for all additional broadcast host_providers
209-
for host_provider in self.config.connect_additional_broadcast().await? {
209+
for host_provider in self.config.connect_additional_broadcast() {
210210
spawn_provider_send!(&host_provider, &tx);
211211
}
212212

‎src/test_utils.rs

+6-3
Original file line numberDiff line numberDiff line change
@@ -11,6 +11,7 @@ use alloy::{
1111
};
1212
use chrono::{DateTime, Utc};
1313
use eyre::Result;
14+
use init4_bin_base::utils::calc::SlotCalculator;
1415
use std::{
1516
str::FromStr,
1617
time::{Instant, SystemTime},
@@ -31,8 +32,7 @@ pub fn setup_test_config() -> Result<BuilderConfig> {
3132
sequencer_key: None,
3233
builder_key: "0000000000000000000000000000000000000000000000000000000000000000".into(),
3334
block_confirmation_buffer: 1,
34-
chain_offset: 0,
35-
target_slot_time: 1,
35+
3636
builder_rewards_address: Address::default(),
3737
rollup_block_gas_limit: 3_000_000_000,
3838
tx_pool_url: "http://localhost:9000/".into(),
@@ -44,7 +44,10 @@ pub fn setup_test_config() -> Result<BuilderConfig> {
4444
oauth_token_refresh_interval: 300, // 5 minutes
4545
builder_helper_address: Address::default(),
4646
concurrency_limit: 1000,
47-
start_timestamp: 1740681556, // pecorino start timestamp as sane default
47+
slot_calculator: SlotCalculator::new(
48+
1740681556, // pecorino start timestamp as sane default
49+
0, 1,
50+
),
4851
};
4952
Ok(config)
5053
}

‎tests/block_builder_test.rs

+1-7
Original file line numberDiff line numberDiff line change
@@ -108,13 +108,7 @@ mod tests {
108108
// Create a rollup provider
109109
let ru_provider = RootProvider::<Ethereum>::new_http(anvil_instance.endpoint_url());
110110

111-
// Create a builder with a test slot calculator
112-
let slot_calculator = SlotCalculator::new(
113-
config.start_timestamp,
114-
config.chain_offset,
115-
config.target_slot_time,
116-
);
117-
let sim = Arc::new(Simulator::new(&config, ru_provider.clone(), slot_calculator));
111+
let sim = Arc::new(Simulator::new(&config, ru_provider.clone(), config.slot_calculator));
118112

119113
// Create a shared sim cache
120114
let sim_cache = SimCache::new();

0 commit comments

Comments
 (0)
Please sign in to comment.