chore(repo): misc updates (#20)

As we're using nightly fmt we can add some nice directives on the rustfmt toml. Also updating the rust version and the org name.

Closes ENG-666

https://www.youtube.com/watch?v=WxnN05vOuSM

Author: Evalir

Cargo.toml

@@ -4,11 +4,11 @@ version = "0.1.1"
 description = "Zenith Builder Example"
 
 edition = "2021"
-rust-version = "1.81"
+rust-version = "1.82"
 authors = ["init4"]
 license = "Apache-2.0 OR MIT"
-homepage = "https://github.com/init4tt/zenith"
-repository = "https://github.com/init4tt/zenith"
+homepage = "https://github.com/init4tech/builder"
+repository = "https://github.com/init4tech/builder"
 
 [lib]
 name = "builder"

bin/builder.rs

@@ -17,10 +17,7 @@ async fn main() -> eyre::Result<()> {
     let provider = config.connect_provider().await?;
     let authenticator = Authenticator::new(&config);
 
-    tracing::debug!(
-        rpc_url = config.host_rpc_url.as_ref(),
-        "instantiated provider"
-    );
+    tracing::debug!(rpc_url = config.host_rpc_url.as_ref(), "instantiated provider");
 
     let sequencer_signer = config.connect_sequencer_signer().await?;
     let zenith = config.connect_zenith(provider.clone());

rustfmt.toml

@@ -0,0 +1,3 @@
+reorder_imports = true
+use_field_init_shorthand = true
+use_small_heuristics = "Max"

src/config.rs

@@ -167,9 +167,7 @@ impl BuilderConfig {
     }
 
     pub async fn connect_builder_signer(&self) -> Result<LocalOrAws, ConfigError> {
-        LocalOrAws::load(&self.builder_key, Some(self.host_chain_id))
-            .await
-            .map_err(Into::into)
+        LocalOrAws::load(&self.builder_key, Some(self.host_chain_id)).await.map_err(Into::into)
     }
 
     pub async fn connect_sequencer_signer(&self) -> Result<Option<LocalOrAws>, ConfigError> {
@@ -198,10 +196,8 @@ impl BuilderConfig {
     ) -> Result<Vec<RootProvider<BoxTransport>>, ConfigError> {
         let mut providers = Vec::with_capacity(self.tx_broadcast_urls.len());
         for url in self.tx_broadcast_urls.iter() {
-            let provider = ProviderBuilder::new()
-                .on_builtin(url)
-                .await
-                .map_err(Into::<ConfigError>::into)?;
+            let provider =
+                ProviderBuilder::new().on_builtin(url).await.map_err(Into::<ConfigError>::into)?;
             providers.push(provider);
         }
         Ok(providers)

src/service.rs

@@ -30,27 +30,18 @@ pub struct AppError {
 impl AppError {
     /// Instantiate a new error with the bad request status code.
     pub fn bad_req<E: std::error::Error + Send + Sync + 'static>(e: E) -> Self {
-        Self {
-            code: StatusCode::BAD_REQUEST,
-            eyre: e.into(),
-        }
+        Self { code: StatusCode::BAD_REQUEST, eyre: e.into() }
     }
 
     /// Instantiate a new error with the bad request status code and an error
     /// string.
     pub fn bad_req_str(e: &str) -> Self {
-        Self {
-            code: StatusCode::BAD_REQUEST,
-            eyre: eyre::eyre!(e.to_owned()),
-        }
+        Self { code: StatusCode::BAD_REQUEST, eyre: eyre::eyre!(e.to_owned()) }
     }
 
     /// Instantiate a new error with the internal server error status code.
     pub fn server_err<E: std::error::Error + Send + Sync + 'static>(e: E) -> Self {
-        Self {
-            code: StatusCode::INTERNAL_SERVER_ERROR,
-            eyre: e.into(),
-        }
+        Self { code: StatusCode::INTERNAL_SERVER_ERROR, eyre: e.into() }
     }
 }
 

src/signer.rs

@@ -50,9 +50,7 @@ impl LocalOrAws {
     async fn aws_signer(key_id: &str, chain_id: Option<u64>) -> Result<AwsSigner, SignerError> {
         let config = aws_config::load_defaults(BehaviorVersion::latest()).await;
         let client = aws_sdk_kms::Client::new(&config);
-        AwsSigner::new(client, key_id.to_string(), chain_id)
-            .await
-            .map_err(Into::into)
+        AwsSigner::new(client, key_id.to_string(), chain_id).await.map_err(Into::into)
     }
 }
 

src/tasks/block.rs

@@ -25,11 +25,7 @@ pub struct InProgressBlock {
 impl InProgressBlock {
     /// Create a new `InProgressBlock`
     pub fn new() -> Self {
-        Self {
-            transactions: Vec::new(),
-            raw_encoding: OnceLock::new(),
-            hash: OnceLock::new(),
-        }
+        Self { transactions: Vec::new(), raw_encoding: OnceLock::new(), hash: OnceLock::new() }
     }
 
     /// Get the number of transactions in the block.
@@ -50,10 +46,8 @@ impl InProgressBlock {
 
     /// Seal the block by encoding the transactions and calculating the contentshash.
     fn seal(&self) {
-        self.raw_encoding
-            .get_or_init(|| encode_txns::<Alloy2718Coder>(&self.transactions).into());
-        self.hash
-            .get_or_init(|| keccak256(self.raw_encoding.get().unwrap().as_ref()));
+        self.raw_encoding.get_or_init(|| encode_txns::<Alloy2718Coder>(&self.transactions).into());
+        self.hash.get_or_init(|| keccak256(self.raw_encoding.get().unwrap().as_ref()));
     }
 
     /// Ingest a transaction into the in-progress block. Fails
@@ -131,19 +125,14 @@ impl BlockBuilder {
     pub fn spawn(
         self,
         outbound: mpsc::UnboundedSender<InProgressBlock>,
-    ) -> (
-        mpsc::UnboundedSender<TxEnvelope>,
-        mpsc::UnboundedSender<Bundle>,
-        JoinHandle<()>,
-    ) {
+    ) -> (mpsc::UnboundedSender<TxEnvelope>, mpsc::UnboundedSender<Bundle>, JoinHandle<()>) {
         let mut in_progress = InProgressBlock::default();
 
         let (tx_sender, mut tx_inbound) = mpsc::unbounded_channel();
         let (bundle_sender, mut bundle_inbound) = mpsc::unbounded_channel();
 
-        let mut sleep = Box::pin(tokio::time::sleep(Duration::from_secs(
-            self.incoming_transactions_buffer,
-        )));
+        let mut sleep =
+            Box::pin(tokio::time::sleep(Duration::from_secs(self.incoming_transactions_buffer)));
 
         let handle = tokio::spawn(
             async move {

src/tasks/bundler.rs

@@ -35,11 +35,7 @@ pub struct BundlePoller {
 impl BundlePoller {
     /// Creates a new BundlePoller from the provided builder config.
     pub async fn new(config: &BuilderConfig, authenticator: Authenticator) -> Self {
-        Self {
-            config: config.clone(),
-            authenticator,
-            seen_uuids: HashMap::new(),
-        }
+        Self { config: config.clone(), authenticator, seen_uuids: HashMap::new() }
     }
 
     /// Fetches bundles from the transaction cache and returns the (oldest? random?) bundle in the cache.
@@ -81,13 +77,15 @@ impl BundlePoller {
         let expired_keys: Vec<String> = self
             .seen_uuids
             .iter()
-            .filter_map(|(key, expiry)| {
-                if expiry.elapsed().is_zero() {
-                    Some(key.clone())
-                } else {
-                    None
-                }
-            })
+            .filter_map(
+                |(key, expiry)| {
+                    if expiry.elapsed().is_zero() {
+                        Some(key.clone())
+                    } else {
+                        None
+                    }
+                },
+            )
             .collect();
 
         for key in expired_keys {

src/tasks/oauth.rs

@@ -46,10 +46,7 @@ impl AuthenticatorInner {
 impl Authenticator {
     /// Creates a new Authenticator from the provided builder config.
     pub fn new(config: &BuilderConfig) -> Self {
-        Self {
-            config: config.clone(),
-            inner: Arc::new(RwLock::new(AuthenticatorInner::new())),
-        }
+        Self { config: config.clone(), inner: Arc::new(RwLock::new(AuthenticatorInner::new())) }
     }
 
     /// Requests a new authentication token and, if successful, sets it to as the token

src/tasks/submit.rs

@@ -116,14 +116,7 @@ impl SubmitTask {
         s: FixedBytes<32>,
         in_progress: &InProgressBlock,
     ) -> eyre::Result<TransactionRequest> {
-        let data = Zenith::submitBlockCall {
-            header,
-            v,
-            r,
-            s,
-            _4: Default::default(),
-        }
-        .abi_encode();
+        let data = Zenith::submitBlockCall { header, v, r, s, _4: Default::default() }.abi_encode();
         let sidecar = in_progress.encode_blob::<SimpleCoder>().build()?;
         Ok(TransactionRequest::default()
             .with_blob_sidecar(sidecar)
@@ -133,9 +126,7 @@ impl SubmitTask {
 
     async fn next_host_block_height(&self) -> eyre::Result<u64> {
         let result = self.provider.get_block_number().await?;
-        let next = result
-            .checked_add(1)
-            .ok_or_else(|| eyre!("next host block height overflow"))?;
+        let next = result.checked_add(1).ok_or_else(|| eyre!("next host block height overflow"))?;
         Ok(next)
     }
 
@@ -163,11 +154,8 @@ impl SubmitTask {
             .with_to(self.config.zenith_address)
             .with_gas_limit(1_000_000);
 
-        if let Err(TransportError::ErrorResp(e)) = self
-            .provider
-            .call(&tx)
-            .block(BlockNumberOrTag::Pending.into())
-            .await
+        if let Err(TransportError::ErrorResp(e)) =
+            self.provider.call(&tx).block(BlockNumberOrTag::Pending.into()).await
         {
             error!(
                 code = e.code,
@@ -251,10 +239,7 @@ impl SubmitTask {
                 sig = hex::encode(sig.as_bytes()),
                 "acquired signature from local signer"
             );
-            SignResponse {
-                req: sig_request,
-                sig,
-            }
+            SignResponse { req: sig_request, sig }
         } else {
             let resp: SignResponse = match self.sup_quincey(&sig_request).await {
                 Ok(resp) => resp,