use crate::{

quincey::Quincey,

tasks::{

block::cfg::SignetCfgEnv,

cache::{BundlePoller, CacheSystem, CacheTask, TxPoller},

env::{EnvTask, SimEnv},

},

};

use alloy::{

network::{Ethereum, EthereumWallet},

primitives::Address,

providers::{

Identity, ProviderBuilder, RootProvider,

fillers::{

BlobGasFiller, ChainIdFiller, FillProvider, GasFiller, JoinFill, NonceFiller,

SimpleNonceManager, WalletFiller,

},

},

};

use eyre::Result;

use init4_bin_base::{

perms::{Authenticator, OAuthConfig, SharedToken},

utils::{

calc::SlotCalculator,

from_env::FromEnv,

signer::{LocalOrAws, SignerError},

},

};

use signet_zenith::Zenith;

use std::borrow::Cow;

use tokio::sync::watch;

/// Type alias for the provider used to simulate against rollup state.

pub type RuProvider = RootProvider<Ethereum>;

/// A [`Zenith`] contract instance using [`Provider`] as the provider.

pub type ZenithInstance<P = HostProvider> = Zenith::ZenithInstance<P, alloy::network::Ethereum>;

/// Type alias for the provider used to build and submit blocks to the host.

pub type HostProvider = FillProvider<

JoinFill<

JoinFill<

JoinFill<

JoinFill<JoinFill<Identity, BlobGasFiller>, GasFiller>,

NonceFiller<SimpleNonceManager>,

>,

ChainIdFiller,

>,

WalletFiller<EthereumWallet>,

>,

RootProvider,

>;

/// Configuration for a builder running a specific rollup on a specific host

/// chain.

#[derive(Debug, Clone, FromEnv)]

pub struct BuilderConfig {

/// The chain ID of the host chain

#[from_env(var = "HOST_CHAIN_ID", desc = "The chain ID of the host chain")]

pub host_chain_id: u64,

/// The chain ID of the rollup chain

#[from_env(var = "RU_CHAIN_ID", desc = "The chain ID of the rollup chain")]

pub ru_chain_id: u64,

/// URL for Host RPC node.

#[from_env(var = "HOST_RPC_URL", desc = "URL for Host RPC node", infallible)]

pub host_rpc_url: Cow<'static, str>,

/// URL for the Rollup RPC node.

#[from_env(var = "ROLLUP_RPC_URL", desc = "URL for Rollup RPC node", infallible)]

pub ru_rpc_url: Cow<'static, str>,

/// Additional RPC URLs to which to broadcast transactions.

/// NOTE: should not include the host_rpc_url value

#[from_env(

var = "TX_BROADCAST_URLS",

desc = "Additional RPC URLs to which the builder broadcasts transactions",

infallible,

optional

)]

pub tx_broadcast_urls: Vec<Cow<'static, str>>,

/// address of the Zenith contract on Host.

#[from_env(var = "ZENITH_ADDRESS", desc = "address of the Zenith contract on Host")]

pub zenith_address: Address,

/// address of the Builder Helper contract on Host.

#[from_env(

var = "BUILDER_HELPER_ADDRESS",

desc = "address of the Builder Helper contract on Host"

)]

pub builder_helper_address: Address,

/// URL for remote Quincey Sequencer server to sign blocks.

/// Disregarded if a sequencer_signer is configured.

#[from_env(

var = "QUINCEY_URL",

desc = "URL for remote Quincey Sequencer server to sign blocks",

infallible

)]

pub quincey_url: Cow<'static, str>,

/// Port for the Builder server.

#[from_env(var = "BUILDER_PORT", desc = "Port for the Builder server")]

pub builder_port: u16,

/// Key to access Sequencer Wallet - AWS Key ID _OR_ local private key.

/// Set IFF using local Sequencer signing instead of remote Quincey signing.

#[from_env(

var = "SEQUENCER_KEY",

desc = "Key to access Sequencer Wallet - AWS Key ID _OR_ local private key, set IFF using local Sequencer signing instead of remote Quincey signing",

infallible,

optional

)]

pub sequencer_key: Option<String>,

/// Key to access Builder transaction submission wallet - AWS Key ID _OR_ local private key.

#[from_env(

var = "BUILDER_KEY",

desc = "Key to access Builder transaction submission wallet - AWS Key ID _OR_ local private key",

infallible

)]

pub builder_key: String,

/// Buffer in seconds in which the `submitBlock` transaction must confirm on the Host chain.

#[from_env(

var = "BLOCK_CONFIRMATION_BUFFER",

desc = "Buffer in seconds in which the `submitBlock` transaction must confirm on the Host chain"

)]

pub block_confirmation_buffer: u64,

/// Address on Rollup to which Builder will receive user transaction fees.

#[from_env(

var = "BUILDER_REWARDS_ADDRESS",

desc = "Address on Rollup to which Builder will receive user transaction fees"

)]

pub builder_rewards_address: Address,

/// Gas limit for RU block.

/// NOTE: a "smart" builder would determine this programmatically by simulating the block.

#[from_env(var = "ROLLUP_BLOCK_GAS_LIMIT", desc = "Gas limit for RU block")]

pub rollup_block_gas_limit: u64,

/// URL of the tx pool to poll for incoming transactions.

#[from_env(

var = "TX_POOL_URL",

desc = "URL of the tx pool to poll for incoming transactions",

infallible

)]

pub tx_pool_url: Cow<'static, str>,

/// Duration in seconds transactions can live in the tx-pool cache.

#[from_env(

var = "TX_POOL_CACHE_DURATION",

desc = "Duration in seconds transactions can live in the tx-pool cache"

)]

pub tx_pool_cache_duration: u64,

/// Oauth2 configuration for the builder to connect to init4 services.

pub oauth: OAuthConfig,

/// The max number of simultaneous block simulations to run.

#[from_env(

var = "CONCURRENCY_LIMIT",

desc = "The max number of simultaneous block simulations to run"

)]

pub concurrency_limit: usize,

/// The slot calculator for the builder.

pub slot_calculator: SlotCalculator,

}

impl BuilderConfig {

/// Connect to the Builder signer.

pub async fn connect_builder_signer(&self) -> Result<LocalOrAws, SignerError> {

LocalOrAws::load(&self.builder_key, Some(self.host_chain_id)).await

}

/// Connect to the Sequencer signer.

pub async fn connect_sequencer_signer(&self) -> eyre::Result<Option<LocalOrAws>> {

if let Some(sequencer_key) = &self.sequencer_key {

LocalOrAws::load(sequencer_key, Some(self.host_chain_id))

.await

.map_err(Into::into)

.map(Some)

} else {

Ok(None)

}

}

/// Connect to the Rollup rpc provider.

pub fn connect_ru_provider(&self) -> RootProvider<Ethereum> {

static ONCE: std::sync::OnceLock<RootProvider<Ethereum>> = std::sync::OnceLock::new();

ONCE.get_or_init(|| {

let url = url::Url::parse(&self.ru_rpc_url).expect("failed to parse URL");

RootProvider::new_http(url)

})

.clone()

}

/// Connect to the Host rpc provider.

pub async fn connect_host_provider(&self) -> eyre::Result<HostProvider> {

let builder_signer = self.connect_builder_signer().await?;

ProviderBuilder::new_with_network()

.disable_recommended_fillers()

.filler(BlobGasFiller)

.with_gas_estimation()

.with_nonce_management(SimpleNonceManager::default())

.fetch_chain_id()

.wallet(EthereumWallet::from(builder_signer))

.connect(&self.host_rpc_url)

.await

.map_err(Into::into)

}

/// Connect additional broadcast providers.

pub fn connect_additional_broadcast(&self) -> Vec<RootProvider> {

self.tx_broadcast_urls

.iter()

.map(|url_str| {

let url = url::Url::parse(url_str).expect("failed to parse URL");

RootProvider::new_http(url)

})

.collect::<Vec<_>>()

}

/// Connect to the Zenith instance, using the specified provider.

pub const fn connect_zenith(&self, provider: HostProvider) -> ZenithInstance {

Zenith::new(self.zenith_address, provider)

}

/// Get an oauth2 token for the builder, starting the authenticator if it

// is not already running.

pub fn oauth_token(&self) -> SharedToken {

static ONCE: std::sync::OnceLock<SharedToken> = std::sync::OnceLock::new();

ONCE.get_or_init(|| {

let authenticator = Authenticator::new(&self.oauth);

let token = authenticator.token();

authenticator.spawn();

token

})

.clone()

}

/// Connect to a Quincey, owned or shared.

pub async fn connect_quincey(&self) -> eyre::Result<Quincey> {

if let Some(signer) = self.connect_sequencer_signer().await? {

return Ok(Quincey::new_owned(signer));

}

let client = reqwest::Client::new();

let url = url::Url::parse(&self.quincey_url)?;

let token = self.oauth_token();

Ok(Quincey::new_remote(client, url, token))

}

/// Create an [`EnvTask`] using this config.

pub async fn env_task(&self) -> EnvTask {

let ru_provider = self.connect_ru_provider();

let host_provider =

self.connect_host_provider().await.expect("failed to configure host provider");

EnvTask::new(self.clone(), ru_provider, host_provider)

}

/// Spawn a new [`CacheSystem`] using this config. This contains the

/// joinhandles for [`TxPoller`] and [`BundlePoller`] and [`CacheTask`], as

/// well as the [`SimCache`] and the block env watcher.

///

/// [`SimCache`]: signet_sim::SimCache

pub fn spawn_cache_system(&self, block_env: watch::Receiver<Option<SimEnv>>) -> CacheSystem {

// Tx Poller pulls transactions from the cache

let tx_poller = TxPoller::new(self);

let (tx_receiver, tx_poller) = tx_poller.spawn();

// Bundle Poller pulls bundles from the cache

let bundle_poller = BundlePoller::new(self, self.oauth_token());

let (bundle_receiver, bundle_poller) = bundle_poller.spawn();

// Set up the cache task

let cache_task = CacheTask::new(block_env.clone(), bundle_receiver, tx_receiver);

let (sim_cache, cache_task) = cache_task.spawn();

CacheSystem { cache_task, tx_poller, bundle_poller, sim_cache }

}

/// Create a [`SignetCfgEnv`] using this config.

pub const fn cfg_env(&self) -> SignetCfgEnv {

SignetCfgEnv { chain_id: self.ru_chain_id }

}

}