chore: delte constants"

Cargo.toml

@@ -25,6 +25,7 @@ path = "bin/submit_transaction.rs"
 init4-bin-base = "0.3"
 
 signet-zenith = { git = "https://github.com/init4tech/signet-sdk", branch = "main" }
+signet-constants = { git = "https://github.com/init4tech/signet-sdk", branch = "main" }
 signet-types = { git = "https://github.com/init4tech/signet-sdk", branch = "main" }
 signet-bundle = { git = "https://github.com/init4tech/signet-sdk", branch = "main" }
 signet-sim = { git = "https://github.com/init4tech/signet-sdk", branch = "main" }

bin/builder.rs

@@ -1,10 +1,7 @@
 use builder::{
     config::BuilderConfig,
     service::serve_builder,
-    tasks::{
-        block::Simulator, bundler, metrics::MetricsTask, oauth::Authenticator, submit::SubmitTask,
-        tx_poller,
-    },
+    tasks::{block::Simulator, bundler, metrics::MetricsTask, submit::SubmitTask, tx_poller},
 };
 use init4_bin_base::{deps::tracing, utils::from_env::FromEnv};
 use signet_sim::SimCache;
@@ -22,35 +19,26 @@ async fn main() -> eyre::Result<()> {
 
     let config = BuilderConfig::from_env()?.clone();
     let constants = SignetSystemConstants::pecorino();
-    let authenticator = Authenticator::new(&config)?;
+    let token = config.oauth_token();
 
-    let (host_provider, sequencer_signer) =
-        tokio::try_join!(config.connect_host_provider(), config.connect_sequencer_signer(),)?;
+    let (host_provider, quincey) =
+        tokio::try_join!(config.connect_host_provider(), config.connect_quincey())?;
     let ru_provider = config.connect_ru_provider();
 
     let zenith = config.connect_zenith(host_provider.clone());
 
-    let metrics = MetricsTask { host_provider: host_provider.clone() };
+    let metrics = MetricsTask { host_provider };
     let (tx_channel, metrics_jh) = metrics.spawn();
 
-    let submit = SubmitTask {
-        token: authenticator.token(),
-        host_provider,
-        zenith,
-        client: reqwest::Client::new(),
-        sequencer_signer,
-        config: config.clone(),
-        outbound_tx_channel: tx_channel,
-    };
+    let submit =
+        SubmitTask { zenith, quincey, config: config.clone(), outbound_tx_channel: tx_channel };
 
     let tx_poller = tx_poller::TxPoller::new(&config);
     let (tx_receiver, tx_poller_jh) = tx_poller.spawn();
 
-    let bundle_poller = bundler::BundlePoller::new(&config, authenticator.token());
+    let bundle_poller = bundler::BundlePoller::new(&config, token);
     let (bundle_receiver, bundle_poller_jh) = bundle_poller.spawn();
 
-    let authenticator_jh = authenticator.spawn();
-
     let (submit_channel, submit_jh) = submit.spawn();
 
     let sim_items = SimCache::new();
@@ -94,9 +82,6 @@ async fn main() -> eyre::Result<()> {
         _ = server => {
             tracing::info!("server finished");
         }
-        _ = authenticator_jh => {
-            tracing::info!("authenticator finished");
-        }
     }
 
     tracing::info!("shutting down");

src/config.rs

@@ -1,4 +1,8 @@
-use crate::signer::{LocalOrAws, SignerError};
+use crate::{
+    quincey::Quincey,
+    signer::{LocalOrAws, SignerError},
+    tasks::oauth::{Authenticator, SharedToken},
+};
 use alloy::{
     network::{Ethereum, EthereumWallet},
     primitives::Address,
@@ -209,4 +213,31 @@ impl BuilderConfig {
     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).unwrap();
+            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))
+    }
 }

src/lib.rs

@@ -12,12 +12,12 @@
 #![deny(unused_must_use, rust_2018_idioms)]
 #![cfg_attr(docsrs, feature(doc_cfg, doc_auto_cfg))]
 
-/// Constants for the Builder.
-pub mod constants;
-
 /// Configuration for the Builder binary.
 pub mod config;
 
+/// Quincey client for signing requests.
+pub mod quincey;
+
 /// Implements the `/healthcheck` endpoint.
 pub mod service;
 

src/quincey.rs

@@ -0,0 +1,80 @@
+use crate::{signer::LocalOrAws, tasks::oauth::SharedToken};
+use alloy::signers::Signer;
+use eyre::bail;
+use init4_bin_base::deps::tracing::{self, debug, info, instrument, trace};
+use oauth2::TokenResponse;
+use reqwest::Client;
+use signet_types::{SignRequest, SignResponse};
+
+/// A quincey client for making requests to the Quincey API.
+#[derive(Debug, Clone)]
+pub enum Quincey {
+    /// A remote quincey, this is used for production environments.
+    /// The client will access the Quincey API over HTTP(S) via OAuth.
+    Remote {
+        /// The remote client.
+        client: Client,
+        /// The base URL for the remote API.
+        url: reqwest::Url,
+        /// OAuth shared token.
+        token: SharedToken,
+    },
+    /// An owned quincey, either local or AWS. This is used primarily for
+    /// testing and development environments. The client will simulate the
+    /// Quincey API using a local or AWS KMS key.
+    Owned(LocalOrAws),
+}
+
+impl Quincey {
+    /// Creates a new Quincey client from the provided URL and token.
+    pub const fn new_remote(client: Client, url: reqwest::Url, token: SharedToken) -> Self {
+        Self::Remote { client, url, token }
+    }
+
+    /// Creates a new Quincey client for making requests to the Quincey API.
+    pub const fn new_owned(client: LocalOrAws) -> Self {
+        Self::Owned(client)
+    }
+
+    async fn sup_owned(&self, sig_request: &SignRequest) -> eyre::Result<SignResponse> {
+        let Self::Owned(signer) = &self else { eyre::bail!("not an owned client") };
+
+        info!("signing with owned quincey");
+        signer
+            .sign_hash(&sig_request.signing_hash())
+            .await
+            .map_err(Into::into)
+            .map(|sig| SignResponse { sig, req: *sig_request })
+    }
+
+    async fn sup_remote(&self, sig_request: &SignRequest) -> eyre::Result<SignResponse> {
+        let Self::Remote { client, url, token } = &self else { bail!("not a remote client") };
+
+        let Some(token) = token.read() else { bail!("no token available") };
+
+        let resp: reqwest::Response = client
+            .post(url.clone())
+            .json(sig_request)
+            .bearer_auth(token.access_token().secret())
+            .send()
+            .await?
+            .error_for_status()?;
+
+        let body = resp.bytes().await?;
+
+        debug!(bytes = body.len(), "retrieved response body");
+        trace!(body = %String::from_utf8_lossy(&body), "response body");
+
+        serde_json::from_slice(&body).map_err(Into::into)
+    }
+
+    /// Get a signature for the provided request, by either using the owned
+    /// or remote client.
+    #[instrument(skip(self))]
+    pub async fn get_signature(&self, sig_request: &SignRequest) -> eyre::Result<SignResponse> {
+        match self {
+            Self::Owned(_) => self.sup_owned(sig_request).await,
+            Self::Remote { .. } => self.sup_remote(sig_request).await,
+        }
+    }
+}

src/tasks/block.rs

@@ -3,7 +3,6 @@
 //! and turns them into valid Pecorino blocks for network submission.
 use crate::{
     config::{BuilderConfig, RuProvider},
-    constants::{BASEFEE_DEFAULT, PECORINO_CHAIN_ID},
     tasks::bundler::Bundle,
 };
 use alloy::{
@@ -347,7 +346,7 @@ impl Simulator {
             Some(basefee) => basefee,
             None => {
                 warn!("get basefee failed - RPC error likely occurred");
-                BASEFEE_DEFAULT
+                todo!()
             }
         };
         debug!(basefee = basefee, "setting basefee");
@@ -433,7 +432,7 @@ impl trevm::Cfg for PecorinoCfg {
     fn fill_cfg_env(&self, cfg_env: &mut CfgEnv) {
         let CfgEnv { chain_id, spec, .. } = cfg_env;
 
-        *chain_id = PECORINO_CHAIN_ID;
+        *chain_id = signet_constants::pecorino::RU_CHAIN_ID;
         *spec = SpecId::default();
     }
 }