fmt

Author: reecepbcups

components/eth-trigger-weather/src/lib.rs

@@ -1,28 +1,32 @@
 mod trigger;
 use layer_wasi::{
     bindings::world::{Guest, TriggerAction},
-    export_layer_trigger_world, wasi::{Request, WasiPollable},
+    export_layer_trigger_world,
+    wasi::{Request, WasiPollable},
 };
-use wstd::runtime::{block_on, Reactor};
-use trigger::{decode_trigger_event, encode_trigger_output};
 use serde::{Deserialize, Serialize};
+use trigger::{decode_trigger_event, encode_trigger_output};
+use wstd::runtime::{block_on, Reactor};
 
 struct Component;
 
 impl Guest for Component {
     fn run(trigger_action: TriggerAction) -> std::result::Result<Vec<u8>, String> {
-        let (trigger_id, req) = decode_trigger_event(trigger_action.data).map_err(|e| e.to_string())?;
+        let (trigger_id, req) =
+            decode_trigger_event(trigger_action.data).map_err(|e| e.to_string())?;
 
         if !req.contains(&b',') {
             return Err("Input must be in the format of City,State".to_string());
         }
         let input = std::str::from_utf8(&req).unwrap(); // TODO:
 
         // open weather API, not wavs specific
-        let api_key = std::env::var("WAVS_ENV_OPEN_WEATHER_API_KEY").or(Err("missing env var `WAVS_ENV_OPEN_WEATHER_API_KEY`".to_string()))?;
+        let api_key = std::env::var("WAVS_ENV_OPEN_WEATHER_API_KEY")
+            .or(Err("missing env var `WAVS_ENV_OPEN_WEATHER_API_KEY`".to_string()))?;
 
         let res = block_on(move |reactor| async move {
-            let loc: Result<LocDataNested, String> = get_location(&reactor, api_key.clone(), input).await;
+            let loc: Result<LocDataNested, String> =
+                get_location(&reactor, api_key.clone(), input).await;
 
             let location = match loc {
                 Ok(data) => data,
@@ -47,18 +51,14 @@ impl Guest for Component {
     }
 }
 
-
 async fn get_location(
     reactor: &Reactor,
     app_key: String,
     loc_input: &str,
 ) -> Result<LocDataNested, String> {
     let url: &str = "http://api.openweathermap.org/geo/1.0/direct";
     let loc_input_formatted = format!("{},US", loc_input);
-    let params = [
-        ("q", loc_input_formatted.as_str()),
-        ("appid", app_key.as_str()),
-    ];
+    let params = [("q", loc_input_formatted.as_str()), ("appid", app_key.as_str())];
 
     let url_with_params = reqwest::Url::parse_with_params(url, &params).unwrap();
     let mut req = Request::get(url_with_params.as_str())?;

components/eth-trigger-weather/src/trigger.rs

@@ -1,12 +1,12 @@
 // Helpers to work with "trigger id" flows - which our example components do
 use alloy_sol_types::SolValue;
 use anyhow::Result;
+use example_submit::ISimpleSubmit::DataWithId;
+use example_trigger::{NewTrigger, TriggerInfo};
 use layer_wasi::{
     bindings::compat::{TriggerData, TriggerDataEthContractEvent},
     ethereum::WasiProvider,
 };
-use example_submit::ISimpleSubmit::DataWithId;
-use example_trigger::{NewTrigger, TriggerInfo};
 
 pub fn decode_trigger_event(trigger_data: TriggerData) -> Result<(u64, Vec<u8>)> {
     match trigger_data {
@@ -24,14 +24,9 @@ pub fn decode_trigger_event(trigger_data: TriggerData) -> Result<(u64, Vec<u8>)>
 }
 
 pub fn encode_trigger_output(trigger_id: u64, output: impl AsRef<[u8]>) -> Vec<u8> {
-    DataWithId {
-        triggerId: trigger_id,
-        data: output.as_ref().to_vec().into(),
-    }
-    .abi_encode()
+    DataWithId { triggerId: trigger_id, data: output.as_ref().to_vec().into() }.abi_encode()
 }
 
-
 mod example_trigger {
     use alloy_sol_macro::sol;
     pub use ISimpleTrigger::TriggerInfo;

crates/bindings/src/addressupgradeable.rs

@@ -42,7 +42,7 @@ pub mod AddressUpgradeable {
     use alloy::contract as alloy_contract;
     /**Creates a new wrapper around an on-chain [`AddressUpgradeable`](self) contract instance.
 
-See the [wrapper's documentation](`AddressUpgradeableInstance`) for more details.*/
+    See the [wrapper's documentation](`AddressUpgradeableInstance`) for more details.*/
     #[inline]
     pub const fn new<
         T: alloy_contract::private::Transport + ::core::clone::Clone,
@@ -56,45 +56,46 @@ See the [wrapper's documentation](`AddressUpgradeableInstance`) for more details
     }
     /**Deploys this contract using the given `provider` and constructor arguments, if any.
 
-Returns a new instance of the contract, if the deployment was successful.
+    Returns a new instance of the contract, if the deployment was successful.
 
-For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+    For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
     #[inline]
     pub fn deploy<
         T: alloy_contract::private::Transport + ::core::clone::Clone,
         P: alloy_contract::private::Provider<T, N>,
         N: alloy_contract::private::Network,
     >(
         provider: P,
-    ) -> impl ::core::future::Future<
-        Output = alloy_contract::Result<AddressUpgradeableInstance<T, P, N>>,
-    > {
+    ) -> impl ::core::future::Future<Output = alloy_contract::Result<AddressUpgradeableInstance<T, P, N>>>
+    {
         AddressUpgradeableInstance::<T, P, N>::deploy(provider)
     }
     /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
-and constructor arguments, if any.
+    and constructor arguments, if any.
 
-This is a simple wrapper around creating a `RawCallBuilder` with the data set to
-the bytecode concatenated with the constructor's ABI-encoded arguments.*/
+    This is a simple wrapper around creating a `RawCallBuilder` with the data set to
+    the bytecode concatenated with the constructor's ABI-encoded arguments.*/
     #[inline]
     pub fn deploy_builder<
         T: alloy_contract::private::Transport + ::core::clone::Clone,
         P: alloy_contract::private::Provider<T, N>,
         N: alloy_contract::private::Network,
-    >(provider: P) -> alloy_contract::RawCallBuilder<T, P, N> {
+    >(
+        provider: P,
+    ) -> alloy_contract::RawCallBuilder<T, P, N> {
         AddressUpgradeableInstance::<T, P, N>::deploy_builder(provider)
     }
     /**A [`AddressUpgradeable`](self) instance.
 
-Contains type-safe methods for interacting with an on-chain instance of the
-[`AddressUpgradeable`](self) contract located at a given `address`, using a given
-provider `P`.
+    Contains type-safe methods for interacting with an on-chain instance of the
+    [`AddressUpgradeable`](self) contract located at a given `address`, using a given
+    provider `P`.
 
-If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
-documentation on how to provide it), the `deploy` and `deploy_builder` methods can
-be used to deploy a new instance of the contract.
+    If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
+    documentation on how to provide it), the `deploy` and `deploy_builder` methods can
+    be used to deploy a new instance of the contract.
 
-See the [module-level documentation](self) for all the available methods.*/
+    See the [module-level documentation](self) for all the available methods.*/
     #[derive(Clone)]
     pub struct AddressUpgradeableInstance<T, P, N = alloy_contract::private::Ethereum> {
         address: alloy_sol_types::private::Address,
@@ -111,29 +112,23 @@ See the [module-level documentation](self) for all the available methods.*/
     /// Instantiation and getters/setters.
     #[automatically_derived]
     impl<
-        T: alloy_contract::private::Transport + ::core::clone::Clone,
-        P: alloy_contract::private::Provider<T, N>,
-        N: alloy_contract::private::Network,
-    > AddressUpgradeableInstance<T, P, N> {
+            T: alloy_contract::private::Transport + ::core::clone::Clone,
+            P: alloy_contract::private::Provider<T, N>,
+            N: alloy_contract::private::Network,
+        > AddressUpgradeableInstance<T, P, N>
+    {
         /**Creates a new wrapper around an on-chain [`AddressUpgradeable`](self) contract instance.
 
-See the [wrapper's documentation](`AddressUpgradeableInstance`) for more details.*/
+        See the [wrapper's documentation](`AddressUpgradeableInstance`) for more details.*/
         #[inline]
-        pub const fn new(
-            address: alloy_sol_types::private::Address,
-            provider: P,
-        ) -> Self {
-            Self {
-                address,
-                provider,
-                _network_transport: ::core::marker::PhantomData,
-            }
+        pub const fn new(address: alloy_sol_types::private::Address, provider: P) -> Self {
+            Self { address, provider, _network_transport: ::core::marker::PhantomData }
         }
         /**Deploys this contract using the given `provider` and constructor arguments, if any.
 
-Returns a new instance of the contract, if the deployment was successful.
+        Returns a new instance of the contract, if the deployment was successful.
 
-For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
+        For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
         #[inline]
         pub async fn deploy(
             provider: P,
@@ -143,10 +138,10 @@ For more fine-grained control over the deployment process, use [`deploy_builder`
             Ok(Self::new(contract_address, call_builder.provider))
         }
         /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
-and constructor arguments, if any.
+        and constructor arguments, if any.
 
-This is a simple wrapper around creating a `RawCallBuilder` with the data set to
-the bytecode concatenated with the constructor's ABI-encoded arguments.*/
+        This is a simple wrapper around creating a `RawCallBuilder` with the data set to
+        the bytecode concatenated with the constructor's ABI-encoded arguments.*/
         #[inline]
         pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<T, P, N> {
             alloy_contract::RawCallBuilder::new_raw_deploy(
@@ -189,10 +184,11 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/
     /// Function calls.
     #[automatically_derived]
     impl<
-        T: alloy_contract::private::Transport + ::core::clone::Clone,
-        P: alloy_contract::private::Provider<T, N>,
-        N: alloy_contract::private::Network,
-    > AddressUpgradeableInstance<T, P, N> {
+            T: alloy_contract::private::Transport + ::core::clone::Clone,
+            P: alloy_contract::private::Provider<T, N>,
+            N: alloy_contract::private::Network,
+        > AddressUpgradeableInstance<T, P, N>
+    {
         /// Creates a new call builder using this contract instance's provider and address.
         ///
         /// Note that the call can be any function call, not just those defined in this
@@ -207,10 +203,11 @@ the bytecode concatenated with the constructor's ABI-encoded arguments.*/
     /// Event filters.
     #[automatically_derived]
     impl<
-        T: alloy_contract::private::Transport + ::core::clone::Clone,
-        P: alloy_contract::private::Provider<T, N>,
-        N: alloy_contract::private::Network,
-    > AddressUpgradeableInstance<T, P, N> {
+            T: alloy_contract::private::Transport + ::core::clone::Clone,
+            P: alloy_contract::private::Provider<T, N>,
+            N: alloy_contract::private::Network,
+        > AddressUpgradeableInstance<T, P, N>
+    {
         /// Creates a new event filter using this contract instance's provider and address.
         ///
         /// Note that the type can be any event, not just those defined in this contract.